Subscribe: Ivan Mitev In The Software Trenches
Added By: Feedage Forager Feedage Grade B rated
Language: English
change  code  company  development  good  might  months  much  net  new  release notes  release  system  time  work  year 
Rate this Feed
Rate this feedRate this feedRate this feedRate this feedRate this feed
Rate this feed 1 starRate this feed 2 starRate this feed 3 starRate this feed 4 starRate this feed 5 star

Comments (0)

Feed Details and Statistics Feed Statistics
Preview: Ivan Mitev In The Software Trenches

Ivan Mitev in the Tech Hive

Brain Dump of a Maker of Delicious Software (Yummy as Honey)

Updated: 2017-12-27T12:53:36.437+02:00


Summary of the year 2017


I am continuing my series of annual retrospectives from 2016, 2015, 2014, 2013, 2012, 2011...After spending a year and a half at Receipt Bank (a quite wonderful company to work for), in October I took a somewhat unexpected opportunity and joined COZYROC in its newly opening development center in Sofia. I am really excited to be a part o a smaller company where I would hopefully be making much greater business impact - by utilizing not just my programming skills, but also my aptitude for strategy & product thinking. I guess I had gotten also a bit nostalgic about programming in C#, too. Returning to the Microsoft development stack I can now more objectively assess what its pros and cons.In Receipt Bank this year I continued with my role as a (mostly) backend developer in the RBA Mobile Apps team, but I also worked on small features in the web app. My productivity in Ruby/Rails improved further and I also developed expertise in various technologies and APIs - Segment, MixPanel, Twilio SMS, etc. It's funny that I changed jobs at a time when I had just started to feel quite competent both in the tech stack and the domain. Overall I felt good about my work at Receipt Bank, as I think I had my fair share in helping it deliver superior products & services to its clients. On the other hand, I was feeling that my opportunities to contribute significantly to the business success of the company were limited, given how much talent RB had already employed. It was quite a difficult decision to leave such a good job and great teammates, but I simply couldn't ignore the opportunity to be among the first COZYROC devs in the Sofia office. I had also wanted to try work on components/developer tools and SSIS looks like an interesting enough space for that. There are a lot of systems and technologies that businesses would probably be interested to integrate with, so variety is more or less guaranteed :)Besides programming, 2017 was a somewhat good year for my physical shape. The last 3 months I started to do some cycling in the park, which I hadn't done in 20+ years. But the highlight of the year was definitely my running practice. I did four 20K runs (Pancharevo, Pleven, Batak, Borisovata Gradina), and also discovered that trail runs are much more fun than city jogging. Unfortunately I got the infamous "runner's knee" problem (obviously I overworked my right knee during my last two 20K runs), but I expect that I would fully recover in the next couple of months. Hopefully I would do a full marathon next year, if all goes well.Wish you a great 2018 year![...]

Code Comments - Friend or Foe?


Recently I had an interesting discussion on code comments, which motivated me to spend some time to research and meditate on this topic. It started with a code review, where I was advised to better remove a comment that I have added. Basically I have added a warning that the code did something with dubious value from the user perspective. Additionally there was nothing in the UI to warn the user what would exactly happen and how to deal with potentially undesired effects. What was special about the situation is that there was nothing wrong with the code implementation-wise, but there was something potentially wrong with the intent behind the code. I also brought the UX issue to the attention of the product owner, but as it wasn't something that seemed to require an immediate action, I felt that I also needed to warn with a code comment the other curious readers. Btw, later it was actually decided to prioritize the issue, so the comment could be safely removed. But if there was no decision to do something about it, other developers might have scratched their heads over the meaning and the value of this code section.Anyway, the bigger topic to tackle here is whether code comments are a friend or a foe. Some  arguments against them are "writing clean code eliminates the need for comments", "code comments should not be an excuse for not fixing things or doing them properly", "code comments are dangerous, as if they get out-of-sync with the code, they only bring confusion". There is definitely an element of truth in all these statements, but all such arguments need to be evaluated in the proper context.I believe it's a false dichotomy to "write clean code vs. write documented code" - why not just do both, if it would make developers' work more efficient and enjoyable. E.g if the code is there to handle some peculiarities of 3rd party system, why not describe those and add some reference links, instead of just having some code without any context.When we analyze the cost of writing comments, we should also try to evaluate the cost of the time wasted, due to not having good comments. There are so many factors in the economics of maintaining code comments that I am sure I can't cover them in a single blog post :)Actually the question if it's worth writing comments is a way too vague, the better question is probably when it's worth to write comments. Or at least when to consider writing comments. My rule of thumb is that whenever it's not clear why this code is there or why it is written in a particular weird way, better consider adding some explanation (assuming there is a good one). Legacy code with poor quality should get special treatment, as it can have a completely different maintenance challenges. Here is one example I am quoting below:"When working with a lot of dense legacy code, you might want to add comments to help you keep track of what you're discovering about what the code is doing, and the dates of particular interventions and fixes that you made. This is not "good" as such, but might be a necessary evil. It's really just a work-around for the lack of better tools to do the same job."Btw, besides clean code, good commit messages can also decrease the need of code comments. But they do have some disadvantages - mainly discoverability and accessibility. A code comment is much harder to ignore than a commit message, as it's in your face. You don't see commit messages unless you look for them. And even if you decide you need to look for them, they might be hard to find. E.g. after multiple changes in the same line of code, "annotate" won't bring you quickly the context that you need to familiarize yourself with. Trying to find the intent and the relevant context from commit messages might be time-consuming and sometimes annoying. Having such information easily-accessible within the code obviously saves you time and energy.This topic certainly has a lot of depth and breadth, and I am just scratching the surface here. If i have to summarize my current take on code comments is that when d[...]

Summary of the year 2016


I am continuing my series of annual retrospectives from 2015, 2014, 2013, 2012, 2011... The highlight of this year for me (professionally) was joining Receipt Bank. It is a really special company that operates extremely well on so many levels - vision, strategy, execution. It is clearly a leader in its domain and it has bold ambitions (that are backed up with smart plans and capable people) to sustain and even accelerate its rapid growth.I already blogged about Receipt Bank here and I can only add that currently I am a part of the RB Mobile Apps team. My main responsibilities are taking care of the backend API and of a couple of features in the web app which would increase the adoption of the mobile apps. I learned a lot about RESTful APIs along the way, as well as I got acquainted to GraphQL (the new promising HTTP APIs paradigm). Besides getting more proficient in Ruby, I also refreshed my Java knowledge a bit by getting to know a part of the code-base of the RB Android app.So yes, 2016 was definitely an interesting year - wrestling with a new programming language (Ruby), new and highly-magical web framework (Rails), new version control (Git, for which I had a quite basic knowledge), database (PostgreSql), various new third-party services (Elastic Search, MixPanel, Twilio, Mandrill, etc), a new operating system (switching to Mac OS after so many years of Windows), etc... With so many new things to get my head around, I am happy I didn't feel almost any "learning fatigue" and that I have overcome the initial frictions to productive work.Let's see what the year 2017 would have in store! Bring it on![...]

7 months with RubyMine


This is a cross-post (with some minor edits) from the internal dev blog of Receipt Bank, which I was motivated to write after a recent company offsite event. Our dev team organized an Unconference, and there were a couple of talks about tools there. Surprisingly I am the only developer in our Ruby team that uses RubyMine for Ruby coding, so I wanted to let my colleagues know why I chose it and why I am quite happy about it.Why I chose RubyMine:RubyMine is part of the JetBrains family - I have enjoyed working with JetBrains tools for years - everything I tried was very polished and improved my productivity significantly. I have been using ReSharper (VS.NET extension) for full 10 years and reached a point where I would simply refuse to do any serious C# development without it. I have also used PyCharm while I was playing with Python (it was, as I expected, quite good, too). Btw, Android Studio (the official Android IDE), that I recently tried, is also based on JetBrains IntelliJ IDEA platform and seems to offer a similarly smooth development experience.RubyMine understands Ruby (and Rails) better than any general purpose text editor. This opens up possibilities of offering some unique features and a superior implementation of other common features (e.g. its code navigation is more reliable than navigation based on simple CTags).A lot of devs, on various internet forums, swear that RubyMine is the best IDE for Ruby development. I even stumbled upon a post by Vim/Emacs user who switched to RubyMine :) Some notable characteristics of JetBrain IDEs:Excellent editor with many built-in features. also extensible (via plugins)Fuzzy search a file, class, etc.Navigation to recent/recently edited files, etc..Flexible windows positioningIntegrated version control, very nice built-in diff editor, quite useful Annotate feature, etc.Integrated database tools - more or less can replace one's DB admin/query Keyboard-friendly - you can assign any command/action a keyboard combinationPlugins - tons of plugins for the IntelliJ platform (i.e. would work on any JetBrains IDE)Ruby/Rails-specific productivity features (listing just a few):Excellent editor for all file types you need -  Ruby, Rails, Slim, ERB, CoffeeScript, Markdown, Yaml, etc.Super nice code navigation, especially useful when working with big and unfamiliar codebases. You can quickly navigate around, even go to gems' code. Navigate from Rails controller to views and vice-versa. Navigate from spec to class and vice-versa, etc...Code completion that works pretty wellCode formatting (instantaneous) + on-demand reformatting. Warnings for formatting inconsistencies.Quick smart code block selection (Cmd + W)Find usages and refactoring features - it's not fully automatic, as Ruby is a dynamic language, but still quite goodPowerful visual test runner that offers everything you need for executing and troubleshooting RSpec and Minitest testsVisual Ruby debugger - yes, an actual debugger with breakpoints. I use it mostly for debugging test runs, as it is somewhat slow to start the with a huge web app. Btw, RubMine support for attach to process is cooking for the next release and it might be useful.Catch errors early - show syntax errors & warnings while you type, warn about typos (via integrated spell checker)Internationalization helpers - preview the English value instead the key, quick jump to key definition, autocomplete of keysGetting started with RubyMine is easy:Has very reasonable defaults - just install RubyMine and you can start coding without much frustrations (i.e. no need to tweak configurations or install additional plugins)Fully configurable key mappings - choose a familiar binding and customize it further, as you wishExcellent features discoverability - good menus organization, intuitive UI, extensive online help, and there is even an action "Find Action" action within the IDELearn as you go - initially you can start discovering and using features by just lookin[...]

My new job at Receipt Bank


It's been now nearly 7 months since I joined Receipt Bank and it's about time to share my impressions. This has been a very intriguing endeavour for me as this is quite a different company from my previous employers. Here is what's so fascinating about my job at RB:
  • Company Size - Receipt Bank is a fast growing SAAS startup, employing more than 150 people, among which around 50 developers (most of them based in Bulgaria, and ~20% based in Slovenia). That's by far the biggest company I have worked for (before RB, the largest dev team I had been a part of was 4 times smaller).
  • Remote Work - That's the first time in my career when I get to work remotely (well, if I am not counting occasional sick days when I had been working from home :) ). Besides Sofia, there are RB developers are in Plovdiv, Burgas, Varna, etc. But the company also holds a nice office next to hotel Hilton, Sofia, so people could work in an office space if they prefer to (or just pass by when they want to socialize face-to-face).
  • Developer Culture - Receipt Bank has by far the best developer culture that I have got a chance to experience first-hand. Very reasonable and constantly improving processes, very smart and capable colleagues, a strong management buy-in for doing whatever it takes to continuously deliver high-quality software. Basically a fantastic place to learn, to improve your skills and to build things you can be proud of.
  • Technology Stack - My main duties in the last 7 months were in supporting and extending the web application and the API of the company's main SAAS product. It's all Ruby on Rails there, which is a quite different beast compared to my beloved C# and ASP.NET. I really liked to try out writing production-class code in a dynamic language like Python or Ruby, and see for my self how it compares to C#. There are pros & cons - e.g. Ruby gives you more freedom, more expressiveness and more magic, but in order to maintain a large code-base you need to write a lot more automated tests.
So yeah, this job is a really big change for me - new development ecosystem, new tools, different processes, etc. Fortunately, after these 7 months I feel comfortable enough with the technology and the business domain and I have the basics to contribute much more effectively to the success of Receipt Bank's products.

Summary of the year 2015


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

I already blogged about the most significant change – my new job at KLEAR. There is not much to add to this topic two months later, besides that we launched a beta version of our free personal budget management web application. I was not involved much in it (just spent one week helping with some infrastructure and deployment stuff), but still it’s nice that we already put out there something that some people can find useful. Well, the first release is lacking in usability (so most likely only advanced users would find it appealing), but it would evolve next year… Anyway, our main focus is the P2P platform and we are making a good progress with the front office and the back office applications.

Technology-wise, it is good that I got to work with ASP.NET MVC. After so many years of ASP.NET WebForms, I find it refreshing. Working with RavenDB is also interesting - my first attempt to introduce a NoSQL database in my previous company 4-5 years ago was unsuccessful (although it was quite a good fit for one of Validata products), so now I finally can develop more in-depth understanding of the technology. I am also improving my frontend development skills – JQuery, Kendo UI, and various other Javascript libraries.

Last year was definitely a year to remember, but I am now looking at what 2016 would offer!

My new job at KLEAR


Five months ago I quit Validata Group where I worked more than 8 years. This was a big change for me, but for many reasons I felt that this was the proper time to move on. I took the summer off to decide what to do next (in the meantime I  traveled a lot - visiting my sister in Mexico, going to a friend's wedding in Germany, and enjoying a 2 week vacation at the Bulgarian seaside).

There were several technology areas which I was planning to explore since years and finally I found the time to do so this summer. After a decade in the .NET world, it was fun to try some Python coding, play with Robot Framework, etc... And just as I was ruminating about a couple of startup ideas with those technologies, I learned about a 3-months old startup called KLEAR who were working on a type of platform that I had not heard about previously - P2P lending. They had a promising sounding job ad for a senior developer and a Facebook page with cool videos. Well, I also happened to know one of the co-founders - as if I needed another compelling reason to learn more about this venture :)

Initially I was quite skeptical about this concept of P2P lending. I couldn't imagine how it was going to attract lenders. Giving money to random strangers and expecting them to return it? Nah, not very attractive idea to risk-averse people (like me :)). But as I read a bit about the 10 year history of p2p lending and its success in UK, US and other countries and as I visited KLEAR office and got to know the company vision from the CEO Loic, I started to change my mind. I realized that the founders know very well what they are doing and that they truly believe they can make this a successful business, which would also have a positive social impact for people that face financial difficulties. They had gathered a team of talented individuals with a lot of experience in the lending business, which were not only coworkers, but friends. KLEAR seemed to me the kind of startup that was doing everything right and I wanted to be a part of it. A week after having a lunch with Lukasz, I joined the company and I have already spent almost 2 months working there.

The more I understand the business and the more I work with the team, the more confident I get that we can build a solid trustworthy P2P lending platform that would benefit both borrowers and lenders. We would be launching the summer of 2016 in Bulgaria, so stay tuned!

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 8th 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 (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 a quite an ambitious project with interesting challenges - both technical and business ones. As it is heavily reporting-related, I got to know a dozen reporting and BI frameworks for a start…
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 have been interesting to me. While there were recent exciting news for the .NET eco system, I think I should jump to something much different. Most likely Python or Javascript (I have been reading a lot about those languages, but without a more hands-on experience, that's not real knowledge).
I am sure that 2015 would be an exciting year!

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!

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 :)
  • 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 subjects to recollect what I was doing in the first three quarters of the year :)

Summary of the year 2011


I am continuing my series of annual retrospectives from 2010, 2008, 2007, 2006 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.[...]

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 and habits. Of course, attitudes and 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, training and feedback.

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.

Summary of the year 2010


I somehow missed to write anything about 2009, but I am continuing my series from 2008, 2007, 2006 and 2005. The most noteworthy change for me this year was my new role as support manager that I undertook for the last nine months of 2010. Initially the plan was just to substitute for a couple of months the person who recently got in charge of the customer support activities, but who had to go on-site to an important project. But I ended up doing this kind of a job for such an extended period of time. I was all the time trying to keep up with my work as developer as much as I can, though there were days when I couldn’t write code even for a minute. It was a very different type of work. Definitely more stressful, especially in the begining. Unlike my dev work, it required often switching between tasks, quickly prioritizing where to put effort and where not. There were times I worked overtime by answering support tickets from home (before going to work or in non-working days), but the worse part is that often my mind continued to go back to the problems at work, even when I was trying to get rid of such thoughts. The nature of this type of work was pretty demanding, as well: It required deep and broad knowledge of many aspects of our products (I guess only a developer can have both). It required knowing which of my colleagues to ask for assistance for particular customer issues (I admit I initially hated to delegate work that I though I would finish more quickly than anybody, but soon I realized that this is not always as effective as it seems). It required an ability to quickly find out what is the customer really wanting and help him get it (either by directly solving his issue or thinking of clever workaround to get the job done in another way). Often it felt very rewarding to help people solve their problems, and as an additional benefit my support work gave me a better understanding of how our products were getting used. This lead to better clarity what matters and what not, so I could concentrate on the truly important things. Being the person responsible for the support, I strived to improve the process in several ways: by customizing the help desk software that we use, by educating our staff and our customers how to use it effectively, by trying to setup proper expectations and attitudes. There were numerous challenges and even several mini-crisis during those nine months. They definitely gave me a better understanding of the bigger picture. They also shaped my vision how things should be done in order to things to go smoothly. It was a valuable experience, but I am happy that I will be handing it back to my colleague, since I think that I would be more valuable in other areas of the product development. My passion for being a developer is stiill strong, but additionally I think I’m a person whose understanding of the product, the technlogies and the customer needs, could be used for architecting proper solutions for the areas that will make a difference for the company and its customers. Besides this role of the support manager, there were other experiences that were new to me: Going on a two-week on-site project – I went to Poland for an on-site work at our client there. I am not used to such type of work, but I think it went very well. Besides answering questions and troubleshooting issues, I also coded a few simple tools that help them solved some problems. The work was diverse and interesting, and it kept me busy all day. It was pretty exhausting too, so I am grateful that my lovely fiancé (now my wife) came for the second week to make my stay in Poland much more pleasant. It really helped me get my work-leasure balance back. Interviewing candidates for a develo[...]

Release notes – less or more structured approaches


Continuing my post from last week, I’ll briefly explain how we maintained a change log in my company for about an year (this was back in 2009) and what were the the things we liked and disliked about it. We used a shared OneNote notebook that had a page per each internal build. After a developer had checked-in a bugfix or some new functionality, he had to describe the change in a free text format, Pasting screenshots was encouraged too, when applicable. The OneNote looked like that: We chose OneNote because of its several conveniences: Easy to setup and use. Allows concurrent editing. Easily searchable. Allows WYSIWYG rich text formatting (including pasting screenshots) Actually we didn’t use many OneNote features. It was just a visually appealing and easy-to-setup wiki. I think it was pretty useful for devs and QAs in terms of shedding more light in the product development. People could quickly got a good idea how features were evolving and be kept up-to-date with the changes in a non-obtrusive way. But there were several things that were not that great about this process: Some developers complained that it was getting too difficult to commit changes: first they had to write checkin comments, then they had to write a resolution in the issue tracking system, and finally they had to update the change log. Though the comment text could slightly differ, sometimes it seemed like a duplication. It was not that easy assemble all the changes for the official release notes from the changelog. One of the reasons was that changes were organzied by date, while it made more sense to have them finally grouped by component and sorted by importance. Also the writing style of developers differs, so it was necessary to rephrase many of the changes. Since the log has loose structure, it was not possible to query the changes, e.g. “find me the fixes by developer X made in the past 2 weeks”. So I was thinking why not capture all release notes information in the issue tracking system itself. The advantages of such approach are obvious, but the system has to meet several requirements for this to work well: Support custom fields (for a text field “DescriptionForReleaseNotes” and probably another one “ImportanceForReleaseNotes”) Support specifying in which release was the change made. Support specifying the component that changed. Support generating a custom report that for any selected release(s) outputs the non-empty changes, grouped by component and sorted by importance. I guess that most popuplar issue tracking systems would support the first three features. I have my doubts only for the report, but some systems might offer powerful enough reporting out of the box. And even if they don’t, exporting the result to Excel and doing some data manipulation there, is an option, too. Another challenge is that this approach assumes that each item in the release notes should describe only one issue in the system, which is not always the case. You might want to group several small changes in one area in a single item. Well, you can just put a value in DescriptionForReleaseNotes for only one of them, but it will be difficult to manage this, unless there is a support for linking the other related issues to the one that contains the description. So linking issues is probably another requirement for this approach to work well. So is it worth commiting to such a highly structured approach of storing release notes? I am not sure. If your issue tracking system can handle such process well, it might be relatively painless to adopt it. But if you have to use another tool just for managing release notes, it might be an overkill. What d[...]

Release notes – whats and hows


So you are asked to prepare a detailed list of changes in the last N months that would be the basis for creating the release notes for the brand new shiny version of your product. Unfortunately you have not been maintaining a change log throughout the product development. Naturally you can’t come up with a detailed list from the top of the head (even for the stuff you developed yourself). In order to do a decent job, several people have to invest hours (or days) to dig out stuff from various sources: the SCM system, the help desk, design documents, e-mails. Under time pressure they have to formulate the changes in a way that they make sense for the target audience. And if the deadline is tight, you might sacrifice the quality of the release notes. That’s stressful and inefficient. But before digging deeper on how to take preventive measures, let’s first take a look at what’s the purpose of release notes/change log and how to prepare them. What is the target audience of a change log/release notes? I initially planned to use the terms “change log”, “release notes” and “revision history” as synonims. But I have a subtle feeling that a change log is for internal audiences, while release notes/revision history are targetted to the end users. A change log also seems to have a connotation of an on-going effort, while release notes are often created just before the release as a one-time effort. It’s clear that not only the end users (current and prospecitve clients) are interested in what’s fixed/ehnahnced/added. A lot of people involved in the product development need such information and they surely need it on a much more regular basis. The list of the internal stakeholders includes QAs, technical writers, developers, customer support, consultants, trainers, management. Probably everyone is interested in slightly different subset (or aspect) of the changes, but to keep things simple let’s examine for now only the differences b/n internal and external change logs. Targeting external vs internal audience The purpose of an external release notes (i.e. publicly visible & easily discoverable) is not only to inform, but most importantly (from the business perspective) is to: Advertise what goodness the new release brings – how does it empower the user (or at least alleviate some of his pain) Increase the confidence in the product and the company behind it - by demonstrating that serious efforts are put in its development and that there is a significant progress on many fronts. The purpose of the internal change log is to make sure that everyone knows what is going on in the development and to take this in consideration while doing their job. It’s necessary to have additional information about the circumstances of the change (e.g. who was the developer behind the change, so he can be contacted later). The purpose here is just to inform (not to persuade), but still the description of each change should be done concisely from the perspective of the product evolution. How release notes should be written? I was looking for an answer of this question myself before deciding to write this post. I found several good answers at stackoverflow and in a blog post. But let’s first take a look at some sample release notes to have some background. I spent a few hours looking at the release notes of a dozen of products (some of which I’ve used, some I’ve just been interested in). Here are a few links of various product types: .NET control suites: Telerik , Infragistics, DevExpress, ComponentOne. VS.NET addins: ReSharper, TestDriven.Net, Typemock, Entrian Source Search SCM systems: Mercurial, PlasticSCM, Subver[...]

Devreach 2010


The 5th edition of Devreach was again excellent - so many world-class speakers, who are passionate about development.

I visited the following sessions:

Anti-Corruption Layers by Donlad Belcham, Level200

What's New in WCF 4 by Miguel Castro, Level 200

Kanban and Scrumban by Joel Semeniuk, Level 200

Leveraging Client Capabilities with jQuery in Visual Studio by Robert Boedigheimer, Level 300

Dynamic State Storage Using the ASP.NET Provider Model by Miguel Castro, Level 300

Customizing TFS to Your Needs by Joel Semeniuk, Level 300

Deep dive into Load Testing features in Visual Studio 2010 by Martin Kulov, Level 300

Worst Practices and Anti-Patterns of Software by Steven Smith, Level 200

Automated Testing in the Agile Environment by Christopher Eyhorn, Level 300

I have to say that none disappointed me – most of them were both informative and entertaining. Altough there were 5 parallel streams of lectures for each time slot (Presentation Layer, Data Layer, Business Layer, Best Practices, Architecture) the titless that grabbed my interest were usually just one or two.

I am not sure how much value the information from this conference would bring to my work, but at least it is refreshing to hear (or get remineded) about various practices, approaches, technologies and fantasize how they might help you in you everyday job.

Summary of the year 2008


Another quite year of blogging, though the last quarter this blog was somewhat resurrected.

It has been 2.5 years since I started working on Validata product. The last year was moderately interesting one,. I worked on various staff, the most notable of which are an HTTP load testing tool (pretty challenging task) and a language parser using ANTLR (just for a week). I also continued to work on our web application and a couple of desktop applications. I feel good that some my ideas finally were implemented and went in production. Also I think my efforts to improve our development process start to pay off...

Unfortunately my pet project with ActiveRecord, Monorail, MySql, JQuery that I got started was put on hold in february, but still it was a good learning experience. After getting to know Monorail, now I quickly got was ASP.NET MVC all about.

Next year, I plan to become an MCTS (I think my company finds more value in those certifications, than I do), so I am starting with 70-536. As a matter of fact, this morning I finally took a practice test from the training kit. I expected to top it without reading a word from the training book, but wishful thinking did not suffice :) I realized that there are areas of the .NET Framework that I don't know enough about i.e. .NET Security, WMI, Interoperability. I wonder if I concentrate only on those areas, will this be enough to pass the exam. Having solid 4 years experience in the .NET world should be a good starting point, so reading a few chapters for a couple of days might be exactly what I need.

Helper for ANTLR Grammar


So I mentioned I am working on a ANTLR grammar (though not for long). And the experience with it was not always smooth.

The problem

  1. We are trying to define a grammar for an existing language which is pretty complex (several hundreds of statements). Every new parser rule had the potential to break the grammar. After inputting several rules, we had difficulty identifying the problematic one. It required a lot of discipline to compile the grammar after each change.
  2. Two developers are preparing the grammar together. Once or twice a day, we are merging the .g file. The merging proved to be quite error-prone.
  3. The ANTLRWorks IDE is not always stable. In some scenarios it freezes and has to be restarted.
  4. The errors and warnings were displayed together, so we had no way of filtering only errors (and we had many warnings).
  5. The C# code generation is buggy in some scenarios - we got an error of a duplicate identifier.
  6. After each compilations we had to overwrite the lexer and parser CS file in our C# project.

The solution

So I wrote an desktop application that monitors the ANTLR grammar file and on each change, it compiles it and does some post-processing to fix the C# code using a simple regex.

Other features

· Specify settings in .config file (grammar file, working folder, antllr install dir)

· View compilation output - complete output, and only errors

· View history of compilation attempts and results

· View notifications as balloon tips (displayed only on significant changes – broken grammar and fixed grammar)

· Automatically save the last successful build in a subfolder of the working folder

Was it worth it?

Yes, automating error-prone operations is always a good idea. We had problems with merging a few times and this continuous compilation enabled us to quickly find the problematic rules. The tool took me initially 3 hours to develop and additional 50% to maintain and bug fix.

How could we extend it?

Generating the C# files from the grammar is not enough. Its output should be included in the project. Then compile successfully. Then pass some unit tests. We have not reached this stage yet.

Points of interest

There is a good discussion here about how to change the .g file, save, hit F5 in Visual Studio and have it use the most recent version of the generated files. Apparently you need a custom tool to do so. A custom tool as a managed assembly that contains a class that implements the IvsSingleFileGenerator interface. Here is a link to an article how to create such a custom tool.

P.S. If you are interested in the code, let me know. I would have uploaded it on CodePlex, but currently it has a dependency to a third-party grid, so I should better use a normal grid, instead.

My Meta Parser


This is fun... I am working now on a task related to ANTLR and its grammar files. Since the grammar file got big and a bit messy, I wrote a small utility to parse the grammar file (.g file) and to sort the parser rules by name. So there it is: a parser of the parser... my meta parser

NOTE: Well, it was not a full-blown parser, but having the parser rules more strictly structured, made it easy enough to implement.

Ways to Compare .NET Assemblies


Sometimes comparing source code is not a viable option, and one has to resort to comparing assemblies (hopefully not obfuscated) to find out what is new, what has changed and what is removed. This kind of activity can be useful in many ways:

  1. Determine what amount of work was done between two releases
  2. Estimate the impact of the changes (e.g. what is needed to be retested).
  3. Spend some work time doing playing with such amusing stuff :)

But how could you do it:

Commercial Tools

NDepend - I have only watched their video and it is impressive. Unfortunately the trial version does not support build comparison, so you should buy the product to try it for yourself. It is a pretty feature rich product that you can use for a variety of reasons.

Bitdiffer - This sole purpose of this tool is comparing assemblies. It lacks some of the NDepend visualizations goodness, but is nevertheless an excellent tool. You might use its GUI application as well as its command line version to automate your work.

Poor Man's Tools

Reflector Diff AddIn - We all love Reflector and this is one of its useful addins. You can either view the differences or you can have a XML report.

Framework Design Studio - There is a short review here. Unfortunately the tool does not work with all assemblies and I can't report good results with it.

VS.NET Macro To Display All File References in a VS.NET Solution


The problem: You have a large solution (mine is with 154 projects) and you want to quick find if you use file references and to what assemblies are they). The solution: see the files below. Add the following module and class and execute ShowAllFileReferencesGroupedByProject() Module: Imports System Imports EnvDTE Imports EnvDTE80 Imports System.Collections.Generic Imports System.Diagnostics Imports System.Text Imports System.Windows.Forms   Public Module VsProjectsManagement       Public Sub ShowAllFileReferencesGroupedByProject()         Dim sb As New StringBuilder()           Dim finder As New FileReferencesFinder()         Dim fileReferences As Dictionary(Of VSLangProj.VSProject, List(Of String)) = finder.GetAllFileReferencesInSolution(True)         Dim sortedProject As New List(Of VSLangProj.VSProject)(fileReferences.Keys)         sortedProject.Sort(AddressOf FileReferencesFinder.CompareProjectsByName)           For Each proj As VSLangProj.VSProject In fileReferences.Keys             sb.Append(proj.Project.Name).Append(" : ").AppendLine()             For Each reference As String In fileReferences.Item(proj)                 sb.AppendLine(reference)             Next             sb.AppendLine()         Next           Debug.Write(sb.ToString)         MessageBox.Show(sb.ToString, "File references")       End Sub Class FileReferencesFinder: Imports System Imports EnvDTE Imports EnvDTE80 Imports System.Collections.Generic Imports System.Diagnostics Imports System.Text Imports System.Windows.Forms   Public Class FileReferencesFinder       Private Function GetAllSolutionVsProjects()         Dim vsProjects As New List(Of VSLangProj.VSProject)         For Each proj As Project In DTE.Solution.Projects             If TypeOf proj.Object Is VSLangProj.VSProject Then                 vsProjects.Add(proj.Object)             End If         Next           Return vsProjects     End Function       Public Shared Function CompareProjectsByName(ByVal prj1 As VSLangProj.VSProject, ByVal prj2 As VSLangProj.VSProject) As Integer         Dim name1 As String = prj1.Project.Name         Dim name2 As String = prj2.Project.Name         Return String.Compare(name1, name2)   [...]

DevReach 2008


A week after the event, I am writing a short review of some of the presentations on DevReach conference

  1. Key Note - by Stephen Forte - very funny keynote. Also a great historical overview of Microsoft strategy for the data access. Steohen showed good examples that Microsoft is a reactive (not a proactive) company.
  2. To AJAX or Not to AJAX by Lino Tadros - Ajax sometimes can be slower, really. Good talk and demos.
  3. Introduction to Test-Driven Development by Stephen Forte - An introduction in TDD, One gem from it was Stephen telling us how to sell TDD to managers - just create regression bugs. Unfortunately Stephen did not tell that TDD is more about about design than testing but another presenter did that in a later session.
  4. Pragmatic ASP.NET Tips, Tricks, and Tools, Part 1 and Pragmatic ASP.NET Tips, Tricks, and Tools, Part 2 by Steven Smith - some useful tips here. This was actually the most practical talk I attended.
  5. Designing for Testability by Hadi Hariri - very good lecture, though it did not turn as interactive as the presenter expected. I am becoming increasingly interested in inversion of control.
  6. SQL Reporting Services 2005 and What's New in 2008 by Remi Caron - I had used RS 2005, but this talk was not for me. SQLRS is not the best tool at the market, but I guess it is popular in Microsoft shops.
  7. Effective Risk Management With and Without Team Foundation Server 2008 by Tadeusz Golonka - the presenter English was really unique. There were a few good ideas how to measure and manage risk.

NOTE: I am pleased that for the first time I saw presenters who used ReSharper in their demos Steven Smith and Hadi Hariri. Both of them used a dark scheme for VS.NET. Unfortunately people complained and they had to switch to the default colors.

XmlWriter design flaws


I was very surprised to see an XmlException (hexadecimal value... is invalid character) when using a XmlReader on a XML file that was generated using a XmlTextWriter. It turned out that the method WriteString(String) does not check for some special characters and an invalid XML document might get generated. See details here.

The recommended workaround was subclassing XmlTextWriter and overriding WriteString() to handle this characters (remove or substitute the invalid characters). XmlTextWriter constructors accept parameters like Stream, TextWriter, but there is also a static factory method XmlWriter.Create(), which has overloads that accept an optional XmlWriterSettings parameter. The weird thing is that if no XmlWriterSettings is specified, then the Settings property of the XmlWriter is null and can not be instantiated, since it is readonly. This means that there is no way to create a subclass (e.g. SafeXmlTextWriter), with initialized Settings property. So, if the default settings are not applicable to your situation... well, tough luck, you can not apply the easy fix using the override:

public override void WriteString(String value)
value = FixInvalidCharacters(value);

Summary of the year 2007


2007 seems a rather quiet year in my career (at least blogging-wise). But it was quiet in a good way :)

It has been 1.5 years since I started working on Validata product and it continues to be mentally stimulating and fun. The diverse technologies in the project and the interesting problems keep me excited about my job. My company has joined a few projects in the Balkans, so the week before Christmas, I had my first business trip, ever. I went for Romania and next week I am going again.

I also have started a pet project that requires learning new stuff like ActiveRecord, Monorail, MySql, JQuery and other good stuff. I really hope to kick it off to a good start, while I am still on vacation. The more challenging thing is to make it a habit to have progress each day, no matter how little it is. I was somewhat unpleasantly surprised when I realized that it has been almost 3 months of inactivity from my last refining of the project idea. But now the project has stable foundations, there are no pending major technology decisions, so the work might just flow...

I have been keeping up with the new .NET stuff mostly from reading my daily doze of weblogs. I also attended a great seminar in Sofia in October, so the saw is still being sharpened :)

I have continued to refine my toolbox and programming techniques. I find that it's worth the temporary discomfort in learning how to use a new tool or technique.

I have a good feeling about the new year. And I will try to make this a self-fulfilling prophecy :)

Have a great new year!

DevReach 2007, Sofia, Bulgaria (Day 2)


Just a few quick notes about the session I visited in the Day 2 of DevReach.Why Partial Rendering Is Not AJAXby Dino Esposito, Level 300Another excellent talk by Dino. I finally cleared some misconceptions in my head about AJAX, partial rendering, update panels and all this stuff. This was a practical talk that will help me a lot when I do AJAX again (the first attempt was a bit unsuccessful, but you know AJAX is not for the faint-hearted).Silverlight, Flash on Steroidsby Lino Tadros, Level 200An excellent talk, by an honest and humorous speaker. Lino's SL demo app was simple and well chosen. But Silverlight is still nor ready for prime time, since the tools are lacking and there are some basic controls missing etc.. (well, when 1.1 is ready, I might take a look at it again).Being Smart About Database Designby Vladi Tchalkov, Level 300Very interesting talk about database design considerations: normalization, domain tables, keys, temporal tables, optimizations. One of the concepts I found very useful was one idea of how to implement temporal tables with a single table for the whole DB. One repeating thread in the talk was "know the rules so that you know how to break them properly".RSS, Podcasting, and Syndicationby Carl Franklin, Level 200A nice talk by the .NET Rocks host Carl Franklin. I learned about the Argotic .NET library. And Carl was very proud that his .NET rocks feed was valid, while the NY times was not (see FeedValidator) :)LINQ - Deep Diveby Branimir Giurov, Level 400Branimir covered in detail all types of LINQ (for objects, datasets, SQL, Entities, XML). He showed the cool debugging support. Good stuff, looking forward to using LINQ.A Busy Developer's Guide to Building Windows PowerShell Cmdletsby Hristo Deshev, Level 200My friend Hristo gave a very interesting talk about PowerShell Cmdlets (he is also writing a book on PowerShell, so he knows his stuff). Those Cmdlets are very fast to build and really powerful. I would like to play with them in case I have to do BAT commands or something more complex.[...]