Husband, father, kabab lover, history buff, chess fan and software engineer. Believes creating software must resemble art: intuitive creation and joyful discovery.

🌎 linktr.ee/bahmanm

Views are my own.

  • 7 Posts
  • 21 Comments
Joined 1 year ago
cake
Cake day: June 26th, 2023

help-circle
  • First off, I was ready to close the tab at the slightest suggestion of using Velocity as a metric. That didn't happen 🙂


    I like the idea that metrics should be contained and sustainable. Though I don't agree w/ the suggested metrics.

    In general, it seems they are all designed around the process and not the product. In particular, there's no mention of the "value unlocked" in each sprint: it's an important one for an Agile team as it holds Product accountable to understanding of what is the $$$ value of the team's effort.

    The suggested set, to my mind, is formed around the idea of a feature factory line and its efficiency (assuming it is measurable.) It leaves out the "meaning" of what the team achieve w/ that efficiency.

    My 2 cents.


    Good read nonetheless 👍 Got me thinking about this intriguing topic after a few years.



  • When i read the title, my immediate thought was “Mojolicious project renamed? To a name w/ an emoji!?” 😂


    We plan to open-source Mojo progressively over time

    Yea, right! I can’t believe that there are people who prefer to work on/with a closed source programming language in 2023 (as if it’s the 80’s.)

    … can move faster than a community effort, so we will continue to incubate it within Modular until it’s more complete.

    Apparently it was “complete” enough to ask the same “community” for feedback.

    I genuinely wonder how they managed to convince enthusiasts to give them free feedback/testing (on github/discord) for something they didn’t have access to the source code.


    PS: I didn’t downvote. I simply got upset to see this happening in 2023.



  • I work primarily on the JVM & the projects (personal/corporate) I work w/ can be summarised as below:

    1. Building & running the repo is done on the host using an SCM (software configuration management tool) such as Gradle or SBT.
    2. The external dependencies of the repo, such as Redis, are managed via adocker-compose.yml.
    3. The README contains a short series of commands to do different tasks RE (1)

    However one approach that I’ve always been fond of (& apply/advocate wherever I can) is to replace (3) w/ a Makefile containing a bunch of standard targets shared across all repos, eg test, integration-test. Then Makefiles are thinly customised to fit the repo’s particular repo.

    This has proven to be very helpful wrt congnitive load (and also CI/CD pipelines): ALL projects, regardless of the toolchain, use the same set of commands, namely

    • make test
    • make integration-test
    • make compose-up
    • make run

    In short (quoting myself here):

    Don’t repeat yourself. Make Make make things happen for you!





  • I used to be in a relatively similar position years ago so I totally relate to what you’ve got to do on a daily basis.

    These are the the titles that come to my mind (leaving ths seniority level up to you):

    • Software engineer
    • Software engineer in Integrations
    • Software engineer in Enterprise Applications
    • ERP Implementation consultant





  • Not a direct answer to your question but here’s what I’ve learned and am learning:

    It all boils down to “finding the right balance between the costs of implementation, the value the implementation offers given the circumstances and constraint.” Essentially, the foundational guideline of engineering across all engineering principles.

    Usually every decision brings about about a series of advantages/improvement but it’s important to remember that “one must lose in order to gain.”[1] That is, every improvement (value) comes at a price (cost). Unlike other principles of engineering (which are closer to bare maths), software engineering more closely resembles something intuition-based like art. That is what makes it difficult to see the values and costs and measure them. It takes lots of practice and introspective and extrospective (!) effort; doing things and potentially making mistakes and learning from them is as important as observing others do things and make mistakes.

    In other words, it boils down to honing your intuition to “do the right thing, at the right time, the right way.”

    PS: Please note that I used the word “right” and not “correct.”

    [1] Dialectically speaking, every material good contains w/i itself its own seeds of destruction 😆









  • I’m a software engineer by profession and passion and have been writing programs for well over 20 years now. I believe your experience is totally natural - at least I share the same feelings:

    1. Large code bases take time getting to know and understand: most definitely true. It takes time and effort and is an investment you need to make before being able to feel confident. You don’t need to fully comprehend every aspect of the project before you can contribute but you sure need to have a decent enough idea of how to build, test, run and deploy a particular feature. See point (2).

    2. Don’t let the size of the project intimidate you. Start small and expand your knowledge base as you go. Usually one good starting point is simply building the project, running tests and deploying it (if applicable.) Then try to take on simple tasks (eg from the project’s issue tracker) and deliver on those (even things like fixing the installation docs, typos, …) That’ll have the additional impact of making you feel good about the work that you’re doing and what you’re learning. I’m sure at this stage you will “know” when you’re confident enough to work on tasks which are a bit bigger.

    3. During (1) and (2), please please do NOT be tempted to just blindly copy-paste stuff at the first sign of trouble. Instead invest some time and try to understand things, what is failing and why it is so. Once you do, it’s totally fine to copy-paste.

    After all, there’s no clear cut formula. Each project is a living and breathing creature and “not one of them is like another.” The only general guideline is patience, curiosity and incremental work.