Mat Kupczyk’s Post

An #architect or #developer must assess each project’s unique requirements and constraints to determine which rules and principles to prioritize. It’s crucial to focus on delivering the right level of quality and functionality that fits the application’s intended usage and aligns with the project’s goals, time frames and resources. This pragmatic approach ensures that the #software meets current needs and is adaptable to future changes, balancing #idealism with #reality.   Here are a few examples of things to guide your architecture choices: 👉 Your #team: a highly skilled team may tend to use advanced concepts and patterns more efficiently, and the learning curve for newcomers should be easier due to the number of seasoned engineers that can support them on the team. Analyze each project individually and find the best patterns to drive them accordingly. 👉 Your #boss: if the company you work for puts pressure on you and your team to deliver complex applications in record time and nobody tells your boss that it is impossible, you may need to cut corners a lot and enjoy many maintenance headaches with crashing systems, painful deployments, and more. I’d go with a very simple design that does not aim at reusability aim at low-to-average testability and #code stuff that just works. 👉 Your #budget: this often depends on the people selling the application and the features. I saw promises that were impossible to keep but delivered anyway with a lot of effort, extra hours, and corner-cutting. The thing to remember when going down that path is that at some point, there is no return from the accumulated technical debt, and it will just get worse. 👉 The #audience: the people who use the software can make a big difference to how you build it: ask them. If you’re aiming your application at multiple clients (web, mobile, and so on), isolating your application’s components and focusing on reusability could be a winning design. 👉 The expected #quality: you should not tackle the problem in the same way for building a prototype and a SaaS application. It is acceptable, even encouraged, for a prototype to have no tests and not follow best practices, but I’d recommend the opposite for a production-quality application. 💡 So just keep the following in mind when building your next piece of software: 1️⃣ Do not over-engineer your applications. 2️⃣ Only implement features that you need, not more, as per the you aren’t gonna need it (YAGNI) principle. 3️⃣ Use your judgment and take the less-worst options; there is no perfect solution.   I hope you found this guidance helpful and that it will serve you in your career, if I can be of assistance, please do not hesitate to contact me => Mohammed BENNAD #agilesoftwaredevelopment #productivity #programming #softwaredesign #softwareengineering

Let's face it: "software engineers" and "software developers" are *not* craftspeople. We are usually a business cost-center that converts business requirements into customer dollars. Setting aside the political baggage of the Software Craftsperson (nee "Craftsman") movement (and those original words alone convey some of the baggage), I find now that I regret the entire movement itself. Paid software development is about serving a business need and rarely about crafting software that is optimized for flexibility, reliability, and understandability. When businesses seek to turn a need into software, they are often concretely planning for a quarter, loosely planning for a year, and pipe-dreaming when they "plan" for anything over three years. This has an impact on software developers. The cost of converting ideas into software usually scales something like logarithmically to exponentially with the complexity of the business. Software is usually developed with an eye toward achieving a quarterly or annual goal or an investment round--so let's say 3 to 12 month window. Management expects to be able to measure results. And, so, in most environments, you need deliverables that can be demonstrated to management in order to show progress. Except for those ideal cases where eXtreme Programming actually works (e.g., customer is always onhand for clarification, no artifacts other than code and test code, team of up to maybe 8 people, often working in pairs, etc.), the complexity of converting business needs into code is complicated bordering on complex because businesses are complicated bordering on complex. (I use the Cynefin definitions of "complicated" and "complex" where "Complicated" means something like"with a reasonable amount of effort, you can somewhat reliably predict outcomes" and "Complex" means that "this system/business is so complicated that you cannot reliably reason about its properties and so properties and outcomes are emergent) Given anything but a project or business with an exceedingly clearly bounded minimum viable product, we're rarely crafting but instead struggling to meet quarterly/annual/funding round deliverables. But wouldn't it be wonderful if we could find our way back to when software developers were able to ship software they could be proud of and businesses were better for it? Perhaps it's still possible. But we all have to be playing a long game, business and developer.

Do you work for a software company?🤔 Oh, so you're a programmer!😅 Not many people outside the IT industry realize that creating software is not solely about coding. Let's shed some light on this issue.👆 Depending on factors like company size and project specifics, the number of roles in a software development team may vary. But in almost 90% of teams, you'll find these seven key players: 📍Business Analyst: The translator and mediator. They are the liaison between the customer and development team. They also help businesses formulate their goals while ensuring that project requirements are clearly understood and effectively communicated to the development team. 📍Product Owner: The ultimate decision-maker. They represent the voice of the customer, prioritize features, and steer the project in the right direction. Product owners focus on delivering the best possible value. 📍Software Architect: The wizard. They design the technical blueprint of the project, making high-level decisions to ensure scalability, reliability, and maintainability. 📍Back-End Developer and Front-End Developer: The dynamic duo behind the code. Back-end developers handle server-side logic, while front-end developers focus on user interfaces. Together, they bring the project to life. And yes, we're talking about coding here! 📍Quality Assurance Engineer: The bug-catcher. This is who verifies whether a solution meets the required specifications and performs all features smoothly. They meticulously test the software, identify flaws and defects, and ensure that the final product meets quality standards. 📍UI/UX Designer: The mind-reader and user-pleaser. They craft intuitive and visually appealing interfaces, ensuring a seamless user experience. No matter the size or scope of your project, having these key roles on your team sets you up for success! Klik Soft provides a range of outstaffing and outsourcing collaboration models for software development, so you don't have to bring on board all these in-house pros. Let us take care of the tech side while you focus on driving your business forward!🚀

The Big Picture in #Software #Development #Projects... Did you communicate it? Research shows that one of the problems that #junior software #developers have is to understand the big picture of a project. This is totally understandable! How many times have you discussed a project's #big #picture with your team? How many actually understand it? If you're the #Team #Lead or the #Product #Owner, have you actually communicated the larger problem, the needs of the solution, the client's expectations? Do you do that with each team member? The way we #communicate with our teams plays a big role in how our team understands the greater scheme of things. But even when you present the project and ask the team to start working on it, junior developers will not ask you for clarifications. They are afraid to ask. The #solution? Have a 1-on-1 with them. After all, it is your responsibility and duty to align your team and to make sure that everyone understands their role, expectations on the project, and the way that the project must be completed. By the way, there's no time like the present. At your next 1-on-1, consider explaining without questioning if the team member understand the big picture. Assume they do, but do it anyway. It will work wonders towards your team's alignment and motivation! How do you make sure your team is aligned when working on a big project? #KeepCoding --------------- Thank you for reading all the way to the end! If you like this content, please 🔔 Follow and 🚀 Share!

Once upon a time, in the realm of software development, there was a team embarking on a journey to create a new software application. 1. Requirement Gathering: As they set out, their first task was to gather requirements from stakeholders. Like explorers mapping out a new land, they sought to understand the needs and desires of those who would use their software. Through careful listening and meticulous documentation, they were able to define the scope and objectives of their project. 2. Design: With their requirements in hand, the team ventured into the design phase. Like architects crafting a blueprint, they sketched out the architecture and user interface of their software. They envisioned a system that was not only functional but also elegant and user-friendly, ensuring that their design would serve as a solid foundation for the development to come. 3. Implementation: With the design finalized, the team dove into implementation. Like builders constructing a new edifice, they began coding, developing databases, and integrating components. Their collaboration was akin to a well-oiled machine, each member contributing their expertise to bring the software to life. 4. Testing: As the software took shape, the team transitioned to the testing phase. Like inspectors scrutinizing every detail of a construction project, they conducted rigorous tests to identify and fix any bugs. Through unit tests, integration tests, and user acceptance tests, they ensured that their software met the highest quality standards. 5. Evolution: Finally, with the software deployed, it entered the evolution phase. Like gardeners tending to a garden, the team monitored its performance, gathered user feedback, and made continuous improvements. They understood that software, like nature, is ever-changing, and they were committed to evolving their creation to meet the needs of their users. In the end, the team's journey through the SDLC was not just a process of building software, but a story of collaboration, creativity, and continuous improvement. It was a testament to the power of teamwork and the importance of following a structured approach to software development. And as their software flourished and grew, so too did their reputation as skilled craftsmen in the world of software development. Follow Naveen chandrawanshi ✅ ✅ Follow Content Studio ✅ ✅ #SDLC #SoftwareDevelopment #RequirementGathering #Design #Implementation #Testing #Evolution #javascript #softwareengineering #coding

Once upon a time, in the realm of software development, there was a team embarking on a journey to create a new software application. 1. Requirement Gathering: As they set out, their first task was to gather requirements from stakeholders. Like explorers mapping out a new land, they sought to understand the needs and desires of those who would use their software. Through careful listening and meticulous documentation, they were able to define the scope and objectives of their project. 2. Design: With their requirements in hand, the team ventured into the design phase. Like architects crafting a blueprint, they sketched out the architecture and user interface of their software. They envisioned a system that was not only functional but also elegant and user-friendly, ensuring that their design would serve as a solid foundation for the development to come. 3. Implementation: With the design finalized, the team dove into implementation. Like builders constructing a new edifice, they began coding, developing databases, and integrating components. Their collaboration was akin to a well-oiled machine, each member contributing their expertise to bring the software to life. 4. Testing: As the software took shape, the team transitioned to the testing phase. Like inspectors scrutinizing every detail of a construction project, they conducted rigorous tests to identify and fix any bugs. Through unit tests, integration tests, and user acceptance tests, they ensured that their software met the highest quality standards. 5. Evolution: Finally, with the software deployed, it entered the evolution phase. Like gardeners tending to a garden, the team monitored its performance, gathered user feedback, and made continuous improvements. They understood that software, like nature, is ever-changing, and they were committed to evolving their creation to meet the needs of their users. In the end, the team's journey through the SDLC was not just a process of building software, but a story of collaboration, creativity, and continuous improvement. It was a testament to the power of teamwork and the importance of following a structured approach to software development. And as their software flourished and grew, so too did their reputation as skilled craftsmen in the world of software development. Follow Naveen chandrawanshi ✅ ✅ Follow Content Studio ✅ ✅ #SDLC #SoftwareDevelopment #RequirementGathering #Design #Implementation #Testing #Evolution #javascript #softwareengineering #coding

Here are the ~8 steps involved in the software cycle, and the ripple effect of screwing up each -> Most reading this got Step 1 wrong -read more 👇 1) Gathering Requirements - asking all of the questions that need to be asked at the beginning to scope it in detail (most of you got this step wrong - everyone does) -> If this is done wrong, nearly everything you're building is completely wrong. A waste of time. A waste of money. Either you'll get somewhat lucky and end up with something somewhat usable (very unlikely) or you'll go broke, scrap it, and move on in life IF YOU GET STEP 1 RIGHT... 2) Turning the Requirements into specs - a non-technical way of defining what it needs to do -> Miss this and the developer will be guessing about everything (= failure most of the time with months building the wrong thing) IF YOU GET STEP 2 RIGHT ALSO... 3) UI and UX - Most people confuse them as being the same, but UX is much harder -> Do this badly and people will have no clue how to use your software IF YOU GET STEP 3 RIGHT ALSO... 4) I call this middle part the "Broken Telephone" of Software Development. this where you need a CTO that can understand the business side and translate it to the technical side. -> If you get everything right before this (which you didn't), but you get this wrong, I'd estimate that 50% of the "message" is transmitted well, 25% is missing, and 25% is wrong. That's the difference between 6-12 months of extra development and having the wrong product built. IF YOU GET STEP 4 RIGHT ALSO... 5) Database Design -> If this is done wrong, your system is crap. Even if you get it live, every little new feature will take forever to get added, and will cause other things to break. This is like the foundation of a building. IF YOU GET STEP 5 RIGHT ALSO... 6) Frontend and Backend Development - "Coding" -> If this is done by someone inexperienced - I mean if the "thinking" of HOW to do it - your system will work like crap. Hard to maintain. Hard to adjust. Hard to add. Constantly having little problems. IF YOU GET STEP 6 RIGHT ALSO... 7) Project Management -> If this isn't done well, everything will be disorganized. Your developers will keep getting sidetracked on things that aren't priorities. Your software (or feature updates) could take additional months to get Live IF YOU GET STEP 7 RIGHT ALSO... 8) Testing -> If not done well, your software will be unusably buggy. If you don't know how to find bugs, they'll stay there. If you don't know how to find hard to find bugs, they'll stay there. If you don't know how to report them properly, your developers won't be able to reproduce them. Your software will stay buggy. Welcome to the madness and fun and building software.

This applies in manufacturing. Replace user with operator, analyst, sales......, al those functions that make up the 5 essential parts of any business.

Make it Work, Make it Right, Make it Fast In the realm of software development, there exists a mantra that encapsulates the essence of crafting quality software: "Make it work, make it right, make it fast." This three-step approach serves as an outline or framework for software development, emphasizing the importance of prioritizing functionality, correctness, and performance in the development process. Of course we want all projects to be elegantly designed, completely correct, easily maintainable and fast, cheap and profitable. But you don't get there in a single step and that's where these phases come to bear. First and foremost, "make it work" underscores the significance of delivering functional software that meets the intended requirements. This initial phase involves prototyping, coding, and iterative testing to ensure that the software performs its intended tasks reliably. This is not a POC, it's an MVP so there may be edge cases that are not yet covered. Once basic functionality is achieved, the focus shifts to "make it right." This phase involves refining the codebase, enhancing readability, and adhering to coding standards and best practices. Emphasis is placed on code hygiene, long term maintenance, ease of reading and extension. You'll also deal with those other edge cases and extend the functionality a bit here.. Finally, "make it fast" addresses the optimization of software performance. This entails identifying bottlenecks, optimizing algorithms, and improving resource utilization to enhance the speed and efficiency of the software. You can substitute words like "efficient, affordable, profitable, and scalable" for "fast" because this is the phase where you really focus on long term ownership and profitability. People have been through this cycle many times will tell you that you need to keep all three phases in mind throughout the project. And they're right. You should always be planning for making things right and fast even when doing the MVP. You just won't try to deliver all of the eventual design in your first delivery. If your initial design considered things like performance and scalability then this last phase is a tuning exercise. If you skipped over the design and design review, this last phase may require revisiting some of your architecture, which is likely to be a disappointment.

Developers universally hate deadlines. Businesses love them. They NEED to know when to expect that button on the "About Us" page. It's going to be a game changer! Learn how to estimate and deliver your work on time and you will be in a small class of developers. I'm still trying to get there myself. 😅 There are entire books written on the magical art of estimation for software projects. 𝗛𝗲𝗿𝗲'𝘀 𝗵𝗼𝘄 𝗜'𝘃𝗲 𝗹𝗲𝗮𝗿𝗻𝗲𝗱 𝘁𝗼 𝘀𝘂𝗰𝗸 𝗺𝘂𝗰𝗵 𝗹𝗲𝘀𝘀 𝗮𝘁 𝗲𝘀𝘁𝗶𝗺𝗮𝘁𝗶𝗼𝗻𝘀 𝗼𝘃𝗲𝗿 𝘁𝗵𝗲 𝘆𝗲𝗮𝗿𝘀: 1. 𝗪𝗿𝗶𝘁𝗲 𝗼𝘂𝘁 𝘁𝗵𝗲 𝘀𝘂𝗯-𝘁𝗮𝘀𝗸𝘀 needed for delivery of a feature and 𝗺𝗮𝗸𝗲 𝗲𝘀𝘁𝗶𝗺𝗮𝘁𝗶𝗼𝗻𝘀 𝗶𝗻 𝗵𝗮𝗹𝗳 𝗱𝗮𝘆𝘀 for all tasks. This includes things like styling.     2. Each day, 𝗺𝗲𝗮𝘀𝘂𝗿𝗲 𝘆𝗼𝘂𝗿 𝗽𝗿𝗼𝗴𝗿𝗲𝘀𝘀 𝗮𝗴𝗮𝗶𝗻𝘀𝘁 𝘁𝗵𝗲 𝘀𝘂𝗯 𝘁𝗮𝘀𝗸𝘀 and see if you're on track or not. 3. Write the actual time next to your original estimation. 4. At the end of the project 𝘂𝘀𝗲 𝘁𝗵𝗲 𝗮𝗱𝗷𝘂𝘀𝘁𝗲𝗱 𝘁𝗶𝗺𝗲𝗹𝗶𝗻𝗲𝘀 𝗳𝗼𝗿 𝗲𝗮𝗰𝗵 𝘁𝗮𝘀𝗸 𝘁𝗼 𝗮𝗰𝗰𝘂𝗿𝗮𝘁𝗲𝗹𝘆 𝗳𝗶𝗴𝘂𝗿𝗲 𝗼𝘂𝘁 𝘁𝗵𝗲 𝘁𝗶𝗺𝗲 𝗳𝗼𝗿 𝘁𝗵𝗲 𝘀𝗶𝗺𝗶𝗹𝗮𝗿 𝗽𝗿𝗼𝗷𝗲𝗰𝘁𝘀. 𝗜𝗳 𝘆𝗼𝘂'𝗿𝗲 𝗮 𝗻𝗲𝘄 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗼𝗿 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝘁𝗼 𝗰𝗼𝗱𝗲 𝘁𝗵𝗲𝗻 𝘂𝘀𝗲 𝘆𝗼𝘂𝗿 𝘀𝗶𝗱𝗲 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝗮𝗻𝗱 𝗮 𝘁𝗮𝘀𝗸 𝗺𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 𝘁𝗼𝗼𝗹 𝗹𝗶𝗸𝗲 𝗧𝗿𝗲𝗹𝗹𝗼 𝘁𝗼 𝗺𝗶𝗺𝗶𝗰 𝘁𝗵𝗶𝘀 𝗽𝗿𝗼𝗰𝗲𝘀𝘀. This will help you understand the time commitment for your side project and when you can expect to complete it.