Here are some of the projects I have been working through my life, feel free to ask questions, share experiences or anything you want to talk about, technologies, system design, tabs versus spaces…

2012 — Zeitek

Vehicle control system

After some time with PHP I decided to try new opportunities, so I got one real big opportunity with a private company who works for the Mexican government, specialized in controlled documents like drivers license, circulation card for vehicles, birth certificates and other secured forms.

My first task there was to create the architecture for a vehicle control system, with payments, fines, and most importantly, valued forms handling (like Circulation card and vehicle plates).

This was the most challenging project that I had, since I had total control over the Technologies, design and technical decisions. The only strict requirement was the use of Java for the web system and Oracle as the database.

The project managers suggested Struts, but after some research, Spring seemed better, with more community and improvements in each release, but since I loved the standards and Java EE 6 was just out of the oven, I created a quick proof of concept and fell in love with the dependency injection and JPA as ORM. I had tried in the past with JE2E, but the extra XML config turned me down, but now there was annotations, allowing me to configure the class in the same file as the code, and this was great, a game changer for me.

So, the stack ended up being:

• Java and Java EE 6
  • JPA Implementation with Hibernate
  • JSF 2.0 for the user interface
  • RichFaces and latter PrimeFaces for the components interface
  • Implementation of dependency injection, transaction management for JPA and partial updates for the interface
• Glassfish server
• Jasperteports for report generation
• Oracle database
• Maven for dependency management
• Subversion and latter git for source management

Some tools used:

• Atlassian products (All introduced, installed and managed by me):
• Jira for task management
• Confluence as documentation hub
• Bitbucket for source code control
• Jaspersoft Studio for report design
• Netbeans as IDE
• JRebel for Java hot update for development (avoid web server restart when the code changes)

I had two project managers, but they were from other state, and their support faded away in early stages of development, latter they helped us from time to time, so I felt happy to take control over the project, but saying that I was responsible of the system success would be far from truth, I had the opportunity to rewrite the selection test for new developers.

(I have share permission, it is not in use anymore), and selected a really great team, which grew up for 2 years from only me, to 5 developers and one tester.

The previous system was old, had no docs, validations, it needed constant restarts and had no reliable information, the migration process included data cleaning, formatting, merging, completing and validation once a citizen made a visit to any of the state offices.

Other of the big difficulties that we found was the fragmentation of the information in the organization itself, some groups thought a process in a certain way, while others was sure it was different, there was no single source of truth, so the taking requirements include being mediator between parts, make standards, formal definitions and create all the validations to have meaningful information in the new system. The system took almost one year in development, from the very start to the first day in production, after that, it entered a cycle of weekly updates including bug fixes, new reports and features.

This was a very personal success for all the team involved since we all where from the same State, so it was great to help at that scale, we could never got official numbers from the previous system, but the improvements in time required to make a government procedure were cut in half or more, and the overall opinion about the system was good, office workers and citizens making procedures said positive things about the new system.

The system was complex, with more than 200 different views with constant changes, and network and hardware restrictions in some offices (some offices had thin clients with less than 250mb of RAM, or connected to old phone modems), but It was also very stable, It could work with no problems in the payments season, when lots of people go to the offices to make procedures, handling between 1 and 1.5 millions of procedures yearly, implemented in around 130 offices around the state. The system was in use from 2014 to 2018, when changes in government forced the implementation of a new integral system with other institutions.

Ended up learning a lot of things from this experience, but to mention some:

• You need to take account of the learning curve of your tools, for a newcomer the full Java EE stack is overwhelming
• The Developer Experience matters (the experience that the developers have when they contribute code to a system), not only the User Experience
• It is better start slow, with solid foundations, and then growing can be faster, starting faster to have “something to show” almost always will slow you down in the future
• It is hard to work for organizations with no organization, before design anything, everybody must be in the same channel, have formally defined roles and tasks
• Your value as programmer it is not only the technical expertise, but the capacity to understand and model the business process of the organization
• Same with the code, its value does not come from the technical complexity, but from the real usefulness and the knowledge that holds for the organization
• Caches are a great tool for information that does not change constantly
• You need to improve both your technical skills, and your people skills, developing system is a group effort, it needs communication, leadership and participation from all parts involved
• And many more things, this was a great experience

The other systems

After the success of the project, I had the opportunity to rework the code to implement Java EE 7 and improve its modularity, making possible to use the same code base in several other projects. It was great to reuse full modules as user, profiles and security control, among a ton of other classes and functionalities.

This allowed us to work in two projects in parallel, sharing improvements and some code parts. The new version included restful endpoints for Android applications. This system base was forked several times for other projects for various States in México.

The system hold a really great flexibility, allowing us to adapt it to our clients requirements, like the use of other databases (It was implemented in Oracle, latter in SQL Server and PostgreSql), the addition of new modules or the personalization of the current ones.

Thanks to keep our accidental complexity low, we could be focused of the business itself, we had to learn legislation and deal with knowledge fragmentation inside the institutions and the lack of systematic procedures, but once the requirements were defined and approved, our response times were praised in several occasions.

I got to travel to some states in México, and worked with some really great people!, after some time I really wanted some new challenges more technical than business oriented, so I moved from my natal state to Monterrey, México.

2010 — TECODA

The same people from our residencies called my friend and me for our good performance to be developers in a small startup working for a seafood store with 7 branch stores. The system started as a simple Point of Sale, with a Java Swing Client in each branch and a central server with a web admin system for the accountants and administrators.

This was our first real big application, the code was a mess, so we started refactoring and improving the performance of several slow pages. The system started to grow with modules like personnel and accounting control, loan handling to employees, credits, product traceability (very important for Federal rules about Seafood distribution), pay sheets and many other things.

Here our stack was:

• Again, PHP with CodeIgniter
• Apache server
• PostgreSql database
• JQuery and heavy ajax usage
• Subversion for source control

In this project we did everything, from doing the interviews with the customers, get the requirements, plan the development, make the changes, test and present to the clients, it was a lot fun! Eventually we had three developers at our charge, teaching guiding and administrating the tasks for them.

Some months later we changed the application to handle a big shoe factory and optimized the code to handle a catalog of more than 75,000 different products with around 250,000 product movements per day.

Sadly, those systems were internal, so I cannot show you some captures, but I can share you what more I learned:

• You need formality for and from the clients, you need to document the requirements, agreements and decision making to keep the stakeholders in the same channel as your team
• The value of your work as architect does not only come from technical knowledge, but also from the business knowledge
• SVN is hard when there is a lot of people
• Writing bad code almost always comes to bite you in the future, some code is only understandable for the developer who wrote it, and after some time not even for himself
• The technical debt is real, expensive and grows exponentially if you do not take care of
• Handle backups, no matter how confident you are in your software and hardware

2009 — COECyT Michoacán

This was during my professional residencies, COECyT means “Consejo Estatal de la Ciencia y Tecnología” (State Council of Science and Technology), here we made some web pages.

I worked with a friend in the sites, again, the pages are no longer available, and others are internal, but some sites looked like this (With the header fixed, I did not find the final version).

2007 — Point of sale for spare parts for mobile phones

This is where my “real” experience started, I played with a lot of things, but this was my first project used in production in a real store.
The project was simple, purchases from providers, sales to clients, some simple reports. It was made with a friend, he oversaw databases and some store procedures, I was in charge of the user interface and the user manual.

The main stack used:

• Java 1.6
• Java Swing for the user interface
• MySQL for the database

The main, or unique idea, was the compatibility list, which allowed to capture the accessory with the models of the cellphones they were compatible, simplifying the training for new employees, this software was in production around four years, and was just spaghetti code glued everywhere, but it worked!

Latter version one was updated by version two, with the same functionality but a reduction in code, here heavy inheritance was implemented in the components, lazy loading for the long lists and a lots of code customization for the interface.

Sadly I do not have the code anymore, but I do have the manual!

What more did I learn:

• Programming is fun with friends
• It is never too early to refactor code
• You need good initial and detailed requirements (If you do not know where you want to go, then you will end in a place where you do not want to be)
• A system in use is a system with change pressure, it is not just that “it works” it needs to be maintainable
• Try to avoid duplicate code