Background and experiences

I work as a software developer in an international team, where we are collaboratively developing an office automation project. Our product is a multi-platform application, and I am specifically focused on the Windows version.

To ensure the quality of our software, we use online static scanners to obtain certification. My responsibilities include uploading prepared packages, running scans, and collecting and analyzing the findings. Following a thorough source code analysis, I address certain findings myself while delegating others to relevant team members for resolution. Once the bugs are fixed, I rescan the software to validate the results and handle any remaining issues.

I am also dedicated to plugin development, designing and implementing new features, resolving bugs, and overall maintenance.

Our development methodology closely resembles Agile, though it’s not a strict Agile framework. We utilize software development tools that facilitate seamless collaboration on tasks, bug fixes, and feature enhancements, ensuring an efficient and organized workflow.

My responsibilities included creating and updating component-level requirements, developing detailed component designs, implementing components, and conducting component testing. We worked as a SCRUM team following Agile methodologies. It was a wonderful experience to collaborate with such a talented international team. Each team member was proficient in integrating components into the final product and debugging it using specialized, self-developed hardware debuggers.

I frequently practiced programming with MISRA compliance checks and conducted Polyspace analysis to ensure code quality.

One of the tasks I particularly enjoyed was conducting source code analysis to identify the root causes of issues affecting the product's behavior. This process was both challenging and rewarding, as it required a deep understanding of the system and ensured the delivery of a high-quality product.

As part of my daily routine, I read through thousands of pages of hardware datasheets and software manuals. Reproducing buggy events that lead to BUG was often a complex process, demanding a thorough knowledge of the software, hardware, and underlying concepts. Despite the challenges, every task helped enhance my skills and broaden my expertise.

At this stage of my career, I began learning how to support users in a factory environment with over 200 workstations. I was also involved in developing Enterprise Management (EM) software, which was built using Qt3 on a Linux platform.

For this system, I developed a background file storage solution using the FTP protocol. I designed and implemented the FTP server myself, ensuring that files on the server could only be accessed via this FTP server through a custom client library integrated into the EM software

Given the company's production quality management system, I developed a specialized application called Measurement Reporter. This software provided an intuitive interface to help operators complete measurement reports as part of a guided protocol before product delivery. It automatically generates reports in PDF format and securely stores the completed reports in the product data repository behind the FTP server.

The measurement instructions were defined in XML files, which could be created and updated using an editor application I designed and implemented in Java. Thanks to Java's cross-platform capabilities, the editor could run seamlessly on both Linux and Windows.

Another noteworthy project involved developing an Android application to support inventory processes. The app allowed users to take product photos as quality assurance evidence. Each photo was stored and linked to a specific product, identified by its serial number.

Another interested development task was when I developed and Android app that supported some inventory process. This app also supported taking photos of product to provide quality level evidence. The app stored the photos and all photo was assigned to certain products identified by their serial number.

I handled a variety of tasks that required a combination of clean design, efficient implementation, and a deep understanding of the user perspective when interacting with the IT infrastructure.

I had another fantastic opportunity to be involved in the development of a customized MS Windows firewall system. Every part of the firewall system was developed from scratch. This system incorporated an Oberthur SmartCard as a token device. The SmartCard was a Java Card, and I was tasked with developing its software, the interface protocol, the card issuer server, and the GINA module for Windows.

The card issuer system was built using a MySQL database server and a Linux desktop as the central card issuing center.

Additionally, I developed a centralized GINA authentication service server. This server was invoked during every user login to verify both the card and the user. The system also included a desktop application for the system operator, enabling them to temporarily or permanently disable any card. The application provided a flexible configuration to assign user rights to specific groups of computers, ensuring highly customizable access control.

After gaining experience in programming SmartCards and developing SmartCard readers and libraries, I became involved in the development of a card issuer hardware box. This device contained 64 SmartCard readers, all connected to a USB bus driven by a specialized single-chip USB hub.

For this device, I developed a Linux device driver module, which was a significant achievement. Additionally, creating a well-functioning Windows device driver presented a real challenge but was ultimately a rewarding experience.

This was an incredible adventure for me. I had the opportunity to participate in the development of a StrongARM-based communication encryption card designed to be plugged into PCs. I was involved in creating the complete firmware for the card, marking the first time I customized a Linux distribution to suit custom hardware. The card communicated with the PC via the PCI bus, utilizing dual-port memory for interaction. It was an amazing experience to program, test, and experiment with the firmware for this product.

During this time, I also learned to use National Rose tools, which provided comprehensive UML-based design capabilities. We used these tools for designing every part of the software, both on the embedded side and the PC side. From that point onward, I have consistently used similar tools to design products, enhancing my approach to software development.

I had the exciting opportunity to develop a Windows device driver for this encryption card, which led me to delve into the world of MS Windows device driver development and Linux driver modules. It was immensely satisfying to see the device drivers operating seamlessly across both operating systems, allowing them to work with the same embedded system. The process of bridging Linux and Windows environments was both challenging and fascinating.

Another memorable experience was developing a SmartCard reader based on the EzUSB chip. Through this project, I gained a deep understanding of communication between a host and a SmartCard. It was my first encounter with this technology, and I studied the fundamentals of SmartCard programming and its usage on the PC side. This project also introduced me to designing and implementing software libraries with identical interfaces for both Windows and Linux, enabling cross-platform compatibility.

These experiences were pivotal in shaping my expertise in embedded systems, device drivers, and cross-platform development.

This was where I began to learn the fundamentals of programming, initiating software projects, and designing software systems. At that time, we didn’t have the user-friendly tools available today. My first software projects were developed using x86 assembly, command-line compilers, and basic text editors. These projects were created in a text-based DOS environment, which posed its own challenges.

One of my early projects involved creating signal digitization applications. These programs acquired analog signals, decoded them, and digitally recorded the processed data. We also worked with Z80 microprocessors on automation projects, designing hardware units for pipelined data processing tasks. The communication between these processing units was carried out over an 8-bit parallel data bus, which added a layer of complexity and excitement to the work.

This period provided an incredible opportunity to learn and practice designing programs and coding them using low-level programming languages. The hands-on experience I gained during these projects laid a strong foundation for my career, knowledge I still draw upon today.

I probably fell in love with programming during those early days when I saw my first applications come to life and function as intended.

As the years went by, both technology and my knowledge advanced together. The shift to using IBM-compatible PCs was a monumental step forward in our professional lives. It opened up opportunities to build more sophisticated and powerful applications, marking a significant evolution in our work.

During this period, I also delved deeply into signal acquisition and processing, learning the intricacies of designing digital networks with integrated circuits. I recall how modern and innovative DIP sockets seemed at the time. Reflecting back now, I smile at how far technology has come since those early days.

These formative experiences were instrumental in shaping my passion for software development and continue to influence my approach to technology and problem-solving today.