Why Most Mobile Development Projects Fail
From This is why most mobile development projects fail
There are many things that can potentially go wrong in a project. I’m sure you
also have your own unique horror story, or stories. But you’re too busy writing
code. There’s no time to take a step back to try to figure out why you’re
feeling this way.
Is this the nature of being a developer? Do all developers feel this way? Are
you going to be feeling like this forever, as long as you are writing code for
Is this really all your fault? Are you the one to blame?
You can try to deflect the blame. You can say this is not your fault. The idea
isn’t as good as you thought it was. The design is too complex. The
requirements are too stringent. The edge cases are too encompassing. There’s
not enough time and budget planned for this large app. Or this team just
doesn’t work well together. Maybe there are communication issues that need to
be dealt with first.
You can also choose to take all the blame. Yes. This is your fault. You didn’t
architect your app properly. You didn’t design and decouple your classes
correctly. You didn’t refactor enough. The unit tests have holes in their
Or somewhere in between. A popular, feel-good, folk tale version. We work as a
team. We fail as a team. We take the fall together as a team. So it’s
everybody’s fault. No finger pointing.
From Rethinking work:-
To start with, I don’t think most people recognize themselves in Adam Smith’s
description of wage-driven idlers. Of course, we care about our wages, and we
wouldn’t work without them. But we care about more than money. We want work
that is challenging and engaging, that enables us to exercise some discretion
and control over what we do, and that provides us opportunities to learn and
grow. We want to work with colleagues we respect and with supervisors who
respect us. Most of all, we want work that is meaningful — that makes a
difference to other people and thus ennobles us in at least some small way.
JWT, JWS & JWT
Basically, the token (JWT) is the simplest structure that you will deal with
while implementing JOSE in our architecture; it is a string representation of
some data base64 encoded (other types of encoding might be applied, but this
is not madatory): the JWT differs from raw base64-encoded data since it also
includes informations about the encoding itself, in the token’s header; by
concatenating the base64-encoded version of the token header and payload (the
actual data) you obtain what the specification calls signature input, which
will then be used to create the signature (JWS).
JWS and JWE
After the JWT comes the JWS, which is a signed representation of the JWT; it
differs from the token just because of the signature; on an higher step of the
ladder comes the JWE instead, which lets you encrypt the data in order to
achieve an higher security level: the examples in the ietf draft show you how
to create JWEs with a pair of private / public keys.