Lulu the Problem Solver
I like problems. I revel in exploring the potential they contain, experimenting with new ideas as I work towards a solution and ultimately, learning from them. I am most comfortable wading through challenges, something there is never a lack of in my every day role as a Software Developer.
Figuring out technical solutions is in every Software Developer’s job scope. Sometimes the only thing in the job scope. At Titansoft, I have no limitations. I participate in Scrum processes daily, brainstorm and co-work with colleagues in different departments, come up with crazy ideas occasionally and best of all, get to actually execute them. I joined the Titansoft Social Committee and had a hand in planning for our Olympics and overseas trip. I am moving on to the annual Dinner and Dance next. I am a Software Developer, but what I do is more than just code.
Staying ahead of the competition is about maintaining speed. About embracing change. About being adaptable. To move beyond trivial constraints and creating new solutions. In a typically “male dominant” role, Titansoft value and supports female developers like me. And to me, that is being adaptable.
The speed at which we accept change and innovate determines our adaptability. We live and breathe our motto – to Never Stop Improving.
This is a good reference book for every programmer in their daily work. It provides the reader with an understanding of the difference between “good code” and “bad code”, and how to transform “bad code” into “good code”. Distilling the Agile practice of cleaning code “on the fly”, each chapter focuses on in-depth specific topics such as Meaningful Names, Functions, Classes and Formatting, with code examples given. It also covers various code smells and includes an introduction to technical practices.
My personal takeaway from this book? "Defend the code with passion and be professional. Learning to write clean code is hard work. It requires more than just principles and patterns. You must practice yourself and watch yourself fail."
Agile Principles, Patterns, and Practices in C#
This is a great book that is worth its weight! The first section illustrates the fundamentals of Agile Development and is a good read for anyone working in the software industry. The second part covers SOLID Principles, Design Patterns and Technical Practices including TDD and Pair Programming which is a must read for all developers. The Agile principles and practices covered in this book will help developers write more maintainable, scalable and testable code. My takeaway from this book is that, "Agile Design is a process, not an event. We need to keep the design as simple, clean and expressive as possible, all the time."
Effective Unit Testing
Best suited for fresh graduates, Effective Unit Testing teaches the writing of unit tests that are concise, expressive, useful and maintainable. Starting with foundational topics explaining the value of tests and using tests as a design tool, it goes on to cover topics related to automation testing and various code smells. Even though examples are in Java, it is still highly recommended for any developers, irrespective of whichever programming language they use. Testing code should be as the same quality as production code and it is important to write maintainable high quality tests.
Working Effectively with Legacy Code
The mechanics of software change and dependency breaking techniques are explained, to work with elements in isolation and make safer changes. It is very common for a developer to come across legacy code at some point in time during their development career, and a long list of way to break dependencies for testing is given here, which will give more confidence to programmers during the development process.
Grab a copy here :
An excellent reference book to understand the refactoring process, Fowler starts with the general principles of refactoring and goes on to provide a catalogue of refactoring and the motivation and mechanics behind each, grouped into sections based on similar functionality. Apply what you learn from this book during development and bug fixing to improve the overall design of your code and to adapt to new changes or features.