Author: Jason Valdez

Jason is a software developer living in Austin, TX.

Interesting webinar on OLAP

Posted on by Jason Valdez

I found these articles and an interesting video on “Is OLAP Dead”…hint, no it isn’t. It will never die!
These are a little old (from Oct 2017), but they have a lot of good summary information.

OLAP: Past, Present…and Future? – This is an article that covers a little history and chats about OLAP as a technology past its prime.

Is OLAP Dead (article) – This is an article that talks about where OLAP is at the time of the article.

Is OLAP Dead (video) – This is a webinar covering a summary of OLAP concepts and technologies.

What I tell Jr Developers

Posted on by Jason Valdez

Software developers love sharing knowledge. If it wasn’t for this one key fact, there wouldn’t be such a large supply of helpful information online for free, which is almost always better than that available for pay.

There are always a lot of younger developers entering the industry. Many of them will do very well without anyone’s help. Others will struggle for years, under utilized, under a paid, under appreciated, and not growing their skill sets.

When I get the chance, I like to chat with junior developers about things they should be aware of and/or actively doing.

  • Software development isn’t all about technology, design patterns, and architecture.
    • Complex software often requires a team of people.
    • The most important thing to be produced from a software development project is working software.
    • Making working software effectively and consistently requires a good software development process.
    • Learn your software development process. Learn how to continuously improve it.
  • Take chances by executing on things that aren’t happening.
    • As a junior developer, the majority of the time you will gain responsibilities because there is no more-senior developer to take them on.
    • As you become more senior, you will have the opportunity to do things that the company isn’t doing because no one is willing to take them on.
    • In all organizations there are people that have defined responsibilities. For those people, that responsibility will be the most important aspect of the company’s inner workings.
      • They will ruin your efforts if they think it is causing them problems or extra work.
      • If at all possible, try not to explicitly give others extra work.
        • You don’t do this out of respect.
        • You do it because they won’t do extra work for you.
  • You won’t learn everything you need to know at your job.
    • All organizations that produce software experience some type of technology lock-in. This is often the result of two concurrent forces.
      • The first is developers who don’t want to to learn new way of doing things.
      • The second is management who desire to standardize on processes and technology.
    • Standardization without continuous improvement leads to organizations that are resistant to change.
      • Change is necessary to achieve long term goals, match industry changes, and client business needs.
  • You won’t learn everything you need to know at one job.
    • Do not plan to stay at your first few positions. Work until you feel you are not learning anything new, then leave for more experiences and always more pay.
    • As a junior developer you need a breadth of experiences. The only way to get those is to work with different businesses, technology, and other developers.
  • Have side projects
    • You must have something to constantly keep your mind active and an outlet to explore things that your job won’t allow.
  • All the real problems in software development are people problems.
    • Technology problems are not major issues for a software development project.
      • A technology problem is just an undiscovered technology solution.
    • The types of problems that kill progress on software projects are people problems.
      • Miscommunications
      • Stalling over decision making authority
      • Interactions with groups outside the immediate software project leading to delays.
      • Ego, fighting, disagreements, etc.

Still Here after 5 years

Posted on by Jason Valdez

For the last four or five years, I’ve made periodic efforts to keep a blog going on software development. It isn’t that I don’t have anything to write about. More, it is that I just don’t have the motivation. I used to have multiple side projects, books to read, as well as leading the way in technology usage where I worked. However, as I moved from a concentration centered around learning about tech to one centered on progression of my career, things outside of work slowed. I’ve had a desire to start more side projects and stop my professional career from dictating my long term learning and experimentation goals.

I’m working on it. I think having a place to write about software development will aid me in doing more learning that isn’t directly about my job. This blog is here for that purpose.

It’s been five years since I really gave blogging any effort. Let’s try this one more time.

Coursera – something new

Posted on by Jason Valdez

I just discovered Coursera.

https://www.coursera.org/courses

I’ve been aware of the progression toward low-cost or no-cost online education, but I had felt like I hadn’t the time to really examine it.

Recently, I had been looking for avenues to grow my skillsets. I decided to give Coursera a try. I’m just putting my toe into the water, though. I don’t feel ready to commit to a lot because I’m not sure how it will work with time constraints. I also have personal projects that I’ve been wanting to get off the ground for a while.

Cryptography seems to be a good starting point.

LINQ Practice project on GitHub

Posted on by Jason Valdez

Note: as of 3/2019 this has been retired

While doing project work for business or pleasure. I often find myself in a position where I need to test out a thought or experiment with some technology. Usually, I simply spin-up a throwaway project.

Linq is one of those technologies that I have used extensively, but in a limited scope. It has been over a year since I had to perform a join operation in Linq, which left me doing some research that reminded me that Linq is rather elaborate and extensive.

To fill out the back story here, I was coding a service recently and implemented a loop to accomplish what could have been done with a Linq join. The reason it had not occurred to me was because I had forgotten the specific join syntax.

For that reason, I put up a project on GitHub for Linq experiments.

https://github.com/JasonDV/LinqPractice (I took this link down)

I plan to expand the project as needed.

Removing strings when using INotifyPropertyChanged

Posted on by Jason Valdez

Update: I wrote this article a long time ago, while I was playing with an idea. Another possibility in C# 6.0 is to use the nameof() utility method.

I had an interesting idea this morning about adding an extension that would allow me to get a method name without using a string value.

The intended use was to add some safety to the use of the INotifyPropertyChanged interface. Most implementations of this interface use a string when calling OnPropertyChanged(“…”). I wanted to do something that would allow me to use refactoring tools to change the name of a property without having to update a string value manually.

As a novelty, I decided to implement it as an extension to all objects. It could just as easily be a utility method.

///
/// UtilExtensions is a class of utility extensions
///
public static class UtilExtensions
{   /// The ToName extensions is added to all non value-type objects.
    public static string ToName<T, P>(this T obj, Expression<Func<T, P>> action) where T : class
    {
        string retVal;

        if (action.Body is MethodCallExpression)
        {
            retVal = ((MethodCallExpression)action.Body).Method.Name;
        }
        else if (action.Body is MemberExpression)
        {
            retVal = ((MemberExpression)action.Body).Member.Name;
        }
        else
        {
            throw new Exception("Unable to determine use: " + action.Body.GetType().ToString());
        }

        return retVal;
    }
}



It would be used like this:


public string MyName
{
    get { return _myName; }
    set {
        _myName = value;

        OnPropertyChanged(this.ToName(x => x.MyName));
    }
}



Apparently, this isn’t a new idea.


While I was researching this I discovered (from other blogs) that there is a new attribute in .NET 4.5 that would help with this issue. The [CallerMemberName] attribute can be used to automatically enter an optional parameter value with the name of the calling method.


It would look like this:


/// Execute the PropertyChanged event.
/// The [CallerMemberName] attribute is used to automatically supply the caller method name.
protected void OnPropertyChanged([CallerMemberName] string name = null)
{
    PropertyChangedEventHandler handler = PropertyChanged;
    if (handler != null)
    {
        handler(this, new PropertyChangedEventArgs(name));
    }
}



Links:

MVVM Light Toolkit – Initial

Posted on by Jason Valdez

I’ve been looking over the MVVM Light Toolkit.

I haven’t had the opportunity to work with WPF extensively, in the past. For the most part, I’ve created custom controls or worked on maintenance of existing applications. Both of these activities keep me away from the architectural aspects of the MVVM. I know that there were several frameworks for the MVVM pattern that had been developed over the years. With my recent change in jobs, I have had the opportunity to start learning about MVVM Light Toolkit.

I’ve only started today, so this post serves mostly as a bookmark.

Toolkit: http://mvvmlight.codeplex.com/

Notes:

  • The CodePlex site has some getting started info, but I found it a bit outdated.
  • You can download an MSI from the CodePlex website, which will add the templates (project, viewmodel, etc.) to Visual Studio.
  • I haven’t tried it, but it should be possible to add the toolkit to an existing project using NuGet.
  • Overview: http://www.galasoft.ch/mvvm/

Getting started video: http://www.youtube.com/watch?v=s-goeb2u3oA

Notes:

  • The ViewModelLocator is very interesting

Hello World!

Posted on by Jason Valdez

I’ve had this domain and blog up for a very long time, but I haven’t had the will to do anything with it. Initially, about two years ago, I wanted to do a tech blog. That didn’t work out for me.

I guess, I actually just wanted a random place to mess around and write about items of interest. That is what I think this will turn into.

We’ll see…