Ivan Mitev In The Software Trenches

Technology weblog on .NET development and other things that make the world go round

December 30, 2014

Summary of the year 2014

I am continuing my series of annual retrospectives from 2013, 2012, 2011, 2010, 2008, 2007, 2006 and 2005...

2014 was my 7th year in Validata. Surprisingly there are still interesting developments that I get the chance to be involved in :)

About half of the year, I had been working on incremental improvements in several of the company’s key products (in terms of performance, usability, newly requested features). I tend to enjoy doing such type of work, especially if it is on foundations that me or someone else has previously laid well).

Besides this, there were a couple of new undertakings. The first was a nice addition to the company portfolio of T24 offerings, where we released a very decent tool in quite short time frames. The other undertaking is yet in the works, so the only thing that I can mention about it, is that it’s an ambitious project with interesting challenges (both technical and business). As it is heavily reporting-related, I got to know in quite well many reporting and BI frameworks…

I am thinking for the next year that it might be good to finally get involved in an open-source project and get a taste of other technologies that are interesting to me. While there were recent exciting news for the .NET eco system, I think I should jump to something different. Most likely Python or Javascript (for both I have some basic knowledge, but not enough in-depth exposure).

I am sure that 2015 would be an exciting year!

December 24, 2013

Summary of the year 2013

I am continuing my series of annual retrospectives from 2012, 2011, 2010, 2008, 2007, 2006 and 2005...

The highlight of this year for me was definitely the birth of my son in January. But this blog is about software, and Stamen still can’t code, so let’s see now how I did professionally:

  • The year started with a month of polishing off a product that is yet to be used for the first time in actual projects. It has already reached a pretty good maturity and a client was close to adopting it, but unfortunately this didn’t happen in 2013. But in the beginning of the next year other clients would finally start using it, and I am excited to see how it will serve their needs.
  • Worked on many maintenance tasks in various functional areas throughout the year. Besides those small stuff, there was one major development that I lead, which I am pretty proud of. It was the next generation of our migration’s solution mapping schemas. The legacy approach had numerous flaws – didn’t scale, didn’t allow expressing intuitively condition logic, wasn’t convenient, wasn’t stable. It was more or less completely redesigned in terms of features, UI and storage. It became a desktop application that resembles a mini-IDE for a visual programming language. There were numerous usability challenges how to make it productive both for developer-minded users and not-so-technical users. And it turned out pretty well. It is being used for more than 3 months in a couple of projects, and the feedback helped us to polish it even further.
  • In the last couple of months I also continued to work on the cloud strategy for our testing product. Participated in some architectural redesign of test execution components, in order to have better deployment flexibility that works outside a LAN (via HTTP).
  • For fun, I spent some time with IronPython. I wanted to experiment with an interpreted language for awhile. Read a couple of books about it, tried it on a small work-related task. It’s certainly a fine language, but since I do most development with C#, I am not sure that the context-switching to IronPython makes me more productive, though for exploratory code it’s definitely nice.

Looking forward to what 2014 has to offer!

December 21, 2012

Summary of the year 2012

I am continuing my series of annual retrospectives from 2011, 2010, 2008, 2007, 2006 and 2005...
Here is how the year 2012 went for me professionally:

  • Expected in 2012 the bulk of my time to go for the role of a team lead/product owner for one of our emerging products, but this turned out to be not a full-time effort (spent just a couple of months on it). So my concerns of too narrow specialization were groundless Smile
  • Lead another project – integration of HP Quality Center with our testing solution. Was glad that I put extensive logging all over the place, otherwise troubleshooting of the issues on-site would have been a PIA.
  • Expected not to spend much time on customer support this year, but there were weeks when my sole assignment was providing technical assistance, especially when troubleshooting difficult issues. I still like it, given that it’s a part of a mix with other activities.
  • Participated in the development of a cloud strategy for the company’s products. It was interesting to get to know Amazon, Azure and other offerings. In the beginning of the year Amazon seemed to be way ahead, but Azure is doing some good catch up work. This project was also a good chance to re-examine the architectural decisions in our products.
  • Several tools, that I had tried to introduced last year, were finally adopted: PlasticSCM for source control management and Jira for task management and issue tracking. The transition was not painless, but it was well worth it. Both release often new versions (especially PlasticSCM) and it’s fascinating to observe the evolution of such best-of-breed products.
  • Worked with several newly hired developers with various experience and personalities. That taught me valuable lessons what to do and what to avoid in such work relationships. Also continued to participate in developers assessment in recruiting campaigns.
  • Kept reading my favourite blogs + some link blogs. Several books that I read recently and liked are Team Geek, Being Geek, User-Centered Design and Making Things Happen.
  • Spent a couple of weeks researching if it’s worth to learn another language. Thanks to stackoverflow contributors, I narrowed down the candidates to Python, Ruby, Powershell, F#, Clojure, Scala, Fantom, Cobra. Wrote my first Python program a couple of months ago, when I needed to organize a big e-mail address list. Have to say I liked the language conciseness. But after all, despite some minor deficiencies  C# is not that bad for a general-purpose language, so I am not sure if I want to invest much time on other languages.

So that’s it for 2012.
P.S. My memory is getting bad. I had to browse through hundreds of e-mail subject to recollect what I was doing in the first three quarters of the year Smile

December 31, 2011

Summary of the year 2011

I am continuing my series of annual retrospectives from 2010200820072006 and 2005...


There just a couple of things that probably deserve a brief mention about the year 2011:

  • I've been given recently a new role in the company I work for - to lead the development of one of our products. It's an interesting challenge. I am a bit reluctant to get overly specialized, since till now I've been contributing in a much broader scope, but on the other side there are benefits in working in a more narrow context.
  • In the last month or so, I've been active in improving the company development process - mainly by assessing our current tools and practices and searching/evaluating others. Most likely we will soon transition to a better version control system (PlasticSCM) and a more powerful issue tracking system (Jira). We might also adopt various other tools to improve our productivity in different parts of the development process.
  • As the previous year, I continued to participate in our developers hiring process (helping with the job ads text, and in candidates assessment). I think I am getting pretty good in guessing  just by looking at a CV a developer's abilities, strengths and weaknesses, (well, the candidate's code still surprise me occasionally, usually unpleasantly ;) ).
  • Mid-year I returned back for a couple of months to my old duties as a Support manager, but hopefully it was temporary. The next year I don't expect to be involved much in this type of work.
  • Technology-wise, there were not that many novelties worth mentioning, besides me getting to know MS SQL Server much better. I planned and participated in supporting of MSSQL as a backend for our applications (we supported only Oracle until recently). Learned a lot from this - e.g. the differences in the default locking models of Oracle/MSSQL turned out to be interesting. Although new technologies are now introduced in our development at a slower rate, I am trying to keep up-to-date with everything interesting in the software development field. Besides the .NET related stuff, there are so many exciting trends to follow, e.g. NoSQL comes easily to mind. And of course, there's much more than the programming frameworks, libraries and tools, it's a big universe...
This pretty much sums it all. Hope that the year 2012 would offer a lot of excitement and positive experiences.

February 12, 2011

On hiring entry-level/junior devs

I was recently asked about my opinion on adding some young & not-experienced people to our dev team, and after I emailed my analysis, I decided the topic is worthy of a blog post.

I’ll first start with the possible disadvantages of hiring junior devs:

· Might be very ineffective compared to more experienced devs, due to lack of necessary knowledge, skills & habits. Of course, attitudes & motivation also affect productivity. Btw, productivity b/n developers might vary significantly.

· Might require significant time (usually the time of senior devs) to train them & supervise them continuously (especially in the first several months)

· More people equals increased time for communication & coordination.

NOTE: When I speak of skills, I guess I should be more specific. Here are a few categories of skills that would determine how effective a developer would be at his work:

· Programming skills – ability to write/understand/debug/modify code efficiently (those include skills working with tools like the IDE, the source control + basic skills like touch-typing)

· Problems solving and design skills – ability to analyze (and redefine) problems, to come up with several solutions and evaluate what’s the best, etc.

· Learning skills – how fast can he learn new things and adopt beneficial practices

· Communication skills – how well the developer expresses his ideas (via code/documentation/e-mails/verbal discussions etc) + how well does he cooperate with others from the team + how willing is he to ask for help when stuck

· “Get into the others shoes” skills – how well he can understand what the client needs + how well he understands how his work is affecting the work of the team.

· Leadership skills – those are probably not software-specific.

 

Though most young people have probably not had the time and the opportunity to develop those skills, there are still probably several advantages in hiring them:

· Easier to find on the market (and cheaper)

· Motivated and energetic (hopefully)

· Free of bad habits – developers with experience are more or less shaped by their experience, and might have accumulated many bad habits that they’ll need to unlearn. Newbies can be molded into good programmers, if given appropriate tasks, attention, training & feedback.

Conclusion

I have a feeling that the best mix is with predominantly senior devs and ~20% junior devs, but I’m sure that other combinations could work fine too.