versioning – The meaning of “Fix Version” field in Jira, while working in agile, microservices and CI/CD processes

When working on a monolith application in a “waterfall” process, a “Fix Version” field makes a lot of sense.

Say you have the “November 2020” planned release, you can add/plan dozens of relevant bugs and features to that release. Other bugs and features may be planned for the next release of “December 2020” and so on. So the “Fix version” field can have the same value for multiple issues/tickets.

Moving to a microservices architecture, the above process is significantly changed – Each microservice has its own release cycles that are completely independent of other MS. If a development team is responsible for 10 different MS, theoretically, each one of them can and should be released without any coupling to the others.

When we add on top of that a CI/CD process, things get even more volatile:

When each and every commit to the master results in a full automation tests suite and potential (or de facto) version that can be deployed to staging/production, then every commit has its own “Fix Version”.

Taking it to the Jira world (or any other issue tracking system) the meaning of that is that each and every ticket/issue may have its own “Fix Version”. No more a common value that is shared across many tickets, but a disposable “Fix Version” value that will be used once.

Moreover, when an issue is created, you have no way to know in which build it will end up, as other tasks may finish before or after it.

In Jira, creating a “Fix Version” is manual, making the process of updating and ticket’s “Fix Version” a tedious and error-prone work.

So my questions are:

  • Are the above assumptions correct?
  • Is there a meaning to a “Fix Version” field in an Agile + Microservices + CI/CD environment?
  • How do you handle the “Fix version” challenge?
  • How do you do it in Jira?

agile – Where to chain multiple applications developed by several feature teams

I am looking how agile methods can be applied for setting up a chained-application (made of several services for example) developed by several teams. In particular, I think the common sources about release-cycle and environment layers (DEV, UAT, PROD) are missing a step where all applications should start to connect with each other.

This level could be called integration-testing, but this concept is used at a lot of levels so it would be confusing: in IoC (Spring) it simply means to connect all software modules/beans of one application together ; in the CI world, this is a place where one team automatically tests its components with respect to normalized/prepared input, that should change only if it is a business or technical requirement that has been validated.

It is missing a cycle step and associated environment where all applications (and data) evolve continuously like in prod, but can and should communicate with each other. This is also the environment that other teams will connect to while developing (in their dev env).

While several team I work with would dedicate one DEV env for that purpose (usually where CD is used), I think this isn’t the right choice because by definition DEV env are freely breakable and deployed version are not (necessary) labeled. I consider this should be done in the UAT environment, on a release or some tagged software version such as a pre-release. Why UAT? because once all parts of the chain are provided (maybe with mock), the users can access it, test it, and provide feedbacks. But maybe I am missing something, and when discussing with my colleagues, not everyone understand me or even agree with me if it doesn’t fit there method.

=> So how agile method answer that issue, and is there good sources that discuss about this?

performance – Apply Agile to the letter

This may seem pedantic, but you cannot apply Agile to the letter, it is just a series of values and principles. There are probably two aspects of what you are referring to. First, there are frameworks and methodologies in the agile umbrella and there are some very strong arguments for following those to the letter (to start). Second, there is an obsession in many industries with best practices and the idea that saying what you will do and then following that no matter what is somehow a good thing (spoilers: it isn’t).

Frameworks in Agile

Scrum, XP, Kanban, etc are all pre-packaged approaches to getting certain results. You don’t have to use them, but they are a shortcut off of someone else’s success (or really, thousands of someone elses). The catch is, you void the warranty if you don’t practice it as intended. Think of it this way: I need a new shelf. I could build a shelf in my garage, but that would require that I buy a bunch of tools, learn carpentry, practice and fail many times. Instead, I’m going to IKEA and buying a shelf. Now, I get the shelf home and I want to put it together. Should I follow the instructions or just start putting screws in holes until I run out of both? Well, it’s my shelf, so I don’t have to follow the instructions, but if I put it together a different way and throw the stabilizing brace in the trash because it uses a flat-head screw and I only have a philips driver, can I really complain when the shelf breaks?

I hope every team that uses scrum or XP eventually grows past it, keeping the parts that work and retooling others to fit their unique context. But you do that after you’ve used the out-of-the-box option and really learned why it works like it does. Then you customize.

Best Practices

To borrow some phrasing from the cynefin model, best practices only work with clear, simple problem. Complicated problems have a whole bunch of “good” practices with each one being slightly better depending on your circumstances. If you get into complex problems, there are only emergent practices. Knowledge work falls almost entirely in complicated and complex spaces, meaning best practices aren’t really applicable. That means no practice should be taken as obviously the right thing to do. Everything is up for review. I have no idea how organizations have become obsessed with best practices, but it’s really problematic.

Now, to tie those together: If I’m using Kanban, I should be using WIP limits. Otherwise, I’m not using Kanban. A corvette with a motorcycle engine in it isn’t a corvette. Does that negate my statement about best practices? No. the practice of WIP limits should be up for review. But if you’ve never used this before, you don’t have the knowledge to effectively evaluate its effectiveness in your context. If you try using a little piece of it, it’s hard to tell if it didn’t work because it’s a bad fit or because you didn’t use the supporting practices alongside. So, you practice one of these frameworks in its entirety to learn how and why they work, then start challenging them.

agile – What are the tried and working software development metodologies?

In my ~10 years of software development I have encountered three software development workflows. I seek an exhaustive list(with explanations) about the remaining functioning ones.

  • Waterfall – gather requirements, sign a contract, deliver in about an year.
  • Agile – gather requirements, sign a contract, update requirement bi-weekly, deliver bi-weekly.
  • Military(just a name, not actual soldiers) – The Boss signs a contract, assigns requirements to line managers, they do 1 on 1s with the devs (OR publish a pull queue of tasks).

This is certainly not an exhaustive list. Agile markets itself as “better than waterfall” but that smells of red herring. There are not only 2 choices, there aught to be plenty!

agile – How can freelancers develop games or web applications on places like fiverr in 3 days for a very cheap price?

I am a computer scientist of a few years and being struggling with finding a focus because I am fascinated with everything… I have been dabbling in the devOps and back-end recently, working on a web application with a small team for 2+ years. For portfolio building and maybe as a side income, I am interested in freelancing. I am estonished by the fact that people are offering very low prices like 20-50 dollars to fully fledged web/mobile apps, or small games delivered in 3 days. I consider myself a good programmer, and we have been working on a single app, albeit a grand scale, for 2 years. I haven’t gotten around a hobby project because it would take “too much time”, it scares me. I am starting to feel kinda incompetent.

What I would like to ask is, how is this possible? I understand 20$ can be big money in some parts of the world, but still, how can they deliver in 3 days? Do these people have prototype libraries or something? I understand templates help immensely, but these seem like domain heavy projects. Are really there fast ways to getting a web app up in such haste? Or is this normal for smallish programs? What is the code quality in there? If this is possible via some tools, what are they? Where can I start to fast prototype apps, even if I would throw them out later, what are some advises to have a streamlined infrastructure?

ux designer – How does Design Thinking, Agile and Lean UX work together?

The way I have come to understand the differences between Design Thinking, Agile and Lean UX is that Design Thinking and Lean UX are frameworks to solve problems where as Agile is a project management methodology.

Design Thinking and Lean UX are very similar at their core. But Design Thinking has gained so much traction in the non UX world that the term has become popularized, even though the UX industry has been practicing this long be fore the term Design Thinking.

Design Thinking at it’s core is:

  • Empathize
  • Define
  • Ideate
  • Prototype
  • Test
  • (Repeat)

Lean UX at it’s core is:

  • Feedback and Research
  • Delcare Assumptions
  • Create an MVP
  • Run an Experiment
  • (Repeat)

Both of these problem solving methodologies roughly follow the double diamond approach.
Double Diamond Diagram

Agile on the other hand is a project management methodology that was created in response to the Waterfall methodology.

Traditionally in Waterfall products would have the full specs created before engineers could get started building. This becomes a problem when you’re building a system for a rocket going to space that takes years to build. Technology can change, new materials can be invented or requirements have shifted from. When things like this happened it’d be detrimental to the project or they would begin developing the specs for the fix.

In Agile specs are written for smaller chunks of the product and put into a prioritized backlog where smaller self sustaining teams can focus on completing a few chunks in a given period of time.

Going back to your original question “How does Design Thinking, Agile and Lean UX work together?”

They don’t… At least not when rigidly implemented.

Traditionally an Agile team would have all the disciplines needed to complete a chunk of work and work in a fixed period of time (Sprints). When Agile was created the Design discipline was not considered since it was an engineering focused methodology.

The reason why they don’t work well together is because as designers we need time for research before we can begin designing something. Given the fixed amount of time in a sprint proper research is often sacrificed in order to finish the designs. Which leads to problems down the road.

That being said, I have heard the terms “Agile-fall” or “Faux Agile aka Fragile” to describe Agile hacks in order for designers to be able to use frameworks like Design Thinking or Lean UX without being a blocker for engineering.

In general “Agile Fall” works something like this: The Design and Engineering teams share the same product backlog, but the Design team is at least 1 sprint ahead of the Engineering team. This gives the Design team the space to use the Design Thinking or Lean UX methodologies to inform their designs before handing off to the engineering team to begin. In effect it is a bunch of small waterfalls. It is all still new since Design as a whole is beginning to be valued on the same level as engineering.

Hope that helps!

ux designer – How do Design thinking, Agile and Lean UX work together?

I have become confused on the different processes involved between Design Thinking, Agile and UX Lean.

I recently read an article that tried to explain how these processes work together am I wanted to check if I have understood these correctly.

The article stated that a UI/UX designer will first run through their process of Design thinking, in order to provide the developers the correct information to build. For example a website. Once the developers start to build, they will follow a agile process, building aspects of the project in stages/sprints.

The results of these sprints are then further tested and feedback is given to the developers to implement, which is how the UI/UX designer is then part of the Agile process.

Is this correct? If so, how does Lean UX fall into this explanation?

What is Disciplined Agile Delivery in a real software development context?

I believe that they’ve moved away from this terminology, but when Disciplined Agile was newer, the creators described it as a “process decision framework”.

DA is centered around high-level activity phases for a project and goals within each phase. These aren’t strict phase-gate phases, but rather a way to organize the goals. However, DA doesn’t tell you how to go about accomplishing these goals. It’s more like a library of practices and information about which ones work well together.

We can take a concrete example of Scrum for more information.

Scrum doesn’t tell you how to form your team. DA recognizes that there are choices to be made about where the team members come from, such as repurposing an existing team or creating a new team. There are also different structures such as feature teams and component teams or geographic distribution of the team or the dedication of the team members (full-time, as needed). All of these are decisions that would be considered as part of DA.

Scrum tells you that you need a potentially releasable product Increment after every Sprint. DA recognizes that there are choices to be made about how to go about doing this. Are you going to be using BDD? TDD? Maybe a combination of both? Are you going to produce formal design specifications? Maybe you’ll be using mob programming to evolve the design with the whole team. Or maybe you’ll build proofs-of-concept and demonstrate those.

There are even higher-level choices. Do you have cadences or do you perform work just-in-time, for example. The same sets of roles, phases, goals, and activities can be used to describe a number of processes. It’s been mapped to a Scrum-based lifecycle, a just-in-time Lean lifecycle, and even an exploratory delivery lifecycle. All of these are built using the same building blocks, with just a different set of choices.

Some choices are mutually exclusive. Some combine well.

You could have 5 organizations adopting Disciplined Agile. They would likely be able to communicate with each other using DA’s fixed sets of roles, phases, and goals. However, each organization may have a different way of satisfying those goals, so their lifecycle would look entirely different.

DA brings a framework that lets an organization build a process lifecycle that is appropriate for their needs. It’s not prescriptive at all, but it guides the organization through the things that need to be thought of along the way and some ideas of common practices that have been known to work.

Is replacing daily scrum meeting by a status email called Agile?

There are different things at play here.

First, Scrum is not the same as SAFe and neither are the same as Agile. Agile Software Development is a set of values and principles. Scrum is a lightweight process framework that is defined in the Scrum Guide and contains a number of roles, events, and artifacts. Scaled Agile Framework (SAFe) is an enterprise-level framework that may or may not be helpful in helping an enterprise embrace agility.

What this means is that a practice that helps promote agility may or may not be in line with the rules of Scrum or SAFe.

Is sending a status email at the end of the day agile? I’m not sure. Maybe, maybe not. One of the principles of Agile Software Development is that “the most efficient and effective method of conveying information to and within a development team is face-to-face conversation”. If there’s no face-to-face (or, in today’s world, 20 years after the Manifesto for Agile Software Development was written, high fidelity voice and video communication), I’m not sure you can be Agile. However, there’s insufficient information to outright say that you aren’t Agile.

Is sending a status email at the end of the day consistent with Scrum? Absolutely not. Scrum is defined in the Scrum Guide and is immutable. That means if you are not following the rules that are specified, you may be doing something that works for you, but the result is not Scrum. One of the key Scrum events is a daily planning and coordination meeting called the Daily Scrum. If the Development Team does not get together for up to 15 minutes for the purposes of planning their day, it’s not Scrum.

Is sending a status email once a day consistent with SAFe? Again, I’d say no. At the team level, SAFe calls for the Daily Stand-Up (DSU). It’s a gathering of the full team at the same time and the same place every day. Since you’re not doing that, I’d be hesitant to call what you’re doing SAFe.

If your team is so distributed, I’d question how effective they are as a team. They may be more like individuals working on a common project. In such a case, perhaps Scrum and SAFe aren’t appropriate for your needs. Most frameworks are built around either co-located teams or at least teams that have not-insignificant overlap in their working hours to support frequent, real-time communication.

agile development – how descriptive should a user story be?

User stories are usually small, used as a definition of a requirement. Epics are large user stories, typically ones which are too big to implement in a single iteration and therefore they need to be disaggregated into smaller user stories.
I would recommend to create an epic containing multiple user stories. Each user story should be an end to end “piece” and all together compose the epic “transaction history”

In Agile development (e.g. SCRUM-based projects) user stories should be Independent, Negotiable, Valuable, Estimable, Small and Testable (INVEST). You need to take under consideration the technical effort depending on the team dynamics. So there is need to create/split a user story accordingly.

Write a Great User Story