Techno Homes Software Organization

Purpose

Structure
The manager of a software company is usually called the Head Of Development
(HOD), and reports to the stakeholders. He or she leads the sub-teams directly or via the
managers/leaders depending on the size of the organization. Usually teams of up to 10
person are the most operational. In bigger organizations, there are in general two models
of the hierarchy:

Mission
Our core mission is to provide top-class software development and related consulting
and business process outsourcing services using cutting-edge technologies, robust
development tools and client oriented approaches.
Our mission is to develop a standardized approach, guidance, and tools that help
decrease the failure rates of software projects, and encourage companies to adopt
these.
We will do this by combining consulting experience and accepted best practices with
the latest techniques in data science. We will accelerate and improve project
management development and deployment activities by publishing on-demand tools,
content, and guidance online. And we will work with partners to build and nurture a
global community to achieve this mission.
Goals
In order to achieve our vision and mission, we are following these goals:
Standardize and codify key software project concepts and terminology
Ensure business goals and objectives are considered at all stages of a project
Develop an accurate and flexible model describing key project activities
Identify and leverage accurate insights into software project success and failure rates
and reasons
Identify and encourage best practices which are appropriate for a particular project
Develop software project activity accelerators
Develop software project risk-reducers
Encourage a spirit of openness, transparency, integrity, trust, and continuous learning
Build and nurture a global community that shares our vision and mission And our
most important goal:
Provably and reliably reduce the cost, effort, duration and risk of software projects

Vision
Our vision is to reduce the remarkably high rate of software project failures worldwide,
by transforming the way companies manage them.
Our vision is to develop in a constant manner and grow as a major IT service provider
to become a leading performer, in providing quality Web and Software Development
solutions in the competitive global marketplace. Our professional, flexible and
integrated process reflects in what we do. We always guide our customers to
success. We have the ability to accelerate and quickly share the great work or
products of your organization or business.
Fortunately, we have been able to bring together a talented crew of professionals
shaped and molded by their collective experiences in the agency, corporate and
private industries, all of which possess outstanding talent. The synergy of what
MacSyn InfoTech does comes from a blend of passion for success and the skill to
help accelerate your organization.

Problems in software organization

Note that when I talk about a software development problem, I mean a problem of any size
and scope:
I am trying to do a very specific thing and I can't get some piece of it to behave as
expected.
I am seeing a strange error message and I have no idea what it means.
I am trying to figure out some cryptic section of a legacy code base when the original
developers have all left the organization.
I know generally what I want to build, but I have no idea what the individual
components of the project will look like.
I am trying to decide what software package to use and I don't know which one is
best.
 I know there's a function to do exactly what I want, but you can't remember what it's
called.

Steps for solve problem

I believe the process of solving a software development problem can be divided into four
steps:
1. Identify the problem
2. Gather information
3. Iterate potential solutions
4. Test your solution

Identify and understand the problem

This is easier in some cases than in others. Sometimes you get a straightforward error
message and I realize I made a simple mistake: a syntax error, forgetting to pass all the
variables I need into a function, neglecting to import a package.
On the other hand, sometimes the error is totally baffling. Often a bug won't present itself
with flashing red lights—the program just doesn't do what I want it to do.
Even when this is the case, I can try your best to articulate the problem. Ask myself the
following questions (and maybe even write down the answers):
What am I trying to do?
What have I done already?
What do I think the program should be doing?
What is it actually doing?

Gathering information
Sometimes I see people skipping straight to this step without having done the previous one.
Examples include:
Googling Stack Overflow as a first step.
Copying and pasting code—whether from Stack Overflow, a tutorial, or elsewhere in
your codebase—without understanding what it does.
I believe this practice leads to “solving” problems without fully understanding them. That's
not to say any of these resources—Stack Overflow, tutorials, any other examples I find—
are bad. But they should be treated as a single tool in our toolbox, not the start and end of
the problem-solving process.
How else can I use this toolbox? Think about the kind of information I am looking for:
If you know exactly what function, class, or API endpoint I am using from an external
package or service, I can go to the relevant page in its documentation to see all the
various options when using it.
If I am having problems with an open-source package and I don’t know why, try
reading the source code for the relevant feature to make sure it’s doing exactly what
I assume it is.
To get an overview of a new tool or framework, try searching for a tutorial or
QuickStart guide.
 If you don’t understand why something in our code base is designed the way it is, try
looking at the commit history for the relevant file or files—often I can piece together
a story of what past developers were trying to do.
And yes, search engines. Sometimes I know exactly what I want to do but I don’t
know what it’s called: “PHP assign two variables.” Sometimes I want ideas on how to
do something: “JavaScript shuffle a deck of cards.” And sometimes I just have no
idea, but looking at other people’s similar problems can help me figure out what to try
next: “Django forms validation not working.” When I do this, try to read any links or
relevant documentation I find to get a broader understanding of the issue.
If I’ve been using one of these methods for a while and I don’t seem to be making progress,
I’ll often switch to another. I find that a lot of developers I know reach for the search engine
first, but for me, intentionally using a variety of methods helps me gain a broader scope of
understanding.

Iterate potential solutions

Try something. It doesn’t have to be perfect. If you see anything change as a result,
that’s a success. You’ll improve on it soon. Then keep trying things until I have made
substantial progress on the problem.
If I am in unfamiliar territory, it can help to break down the “solution” into very small
increments, and try them out piece by piece. Print our data to the console before I
worry about how it’ll be rendered. Call a function I haven’t used before with simple
hardcoded arguments, and get it to run as expected before replacing them with the
actual data I’ll be using in our application.
This still applies if I am using someone else’s code from Stack Overflow or a tutorial
as an example. Don’t just copy and paste the code into our editor—type out the code
line by line. This has two advantages. First, I am forced to engage with the code and
understand it in more detail. Second, I’ll have the chance to update anything that
doesn’t translate perfectly to our application. Maybe I can leave out a variable I won’t
use; maybe their example uses class Animal and I am trying to sort Books, so I’d
replace a variable called species with one called title.
Sometimes it’s harder to try out what I am doing after every line of code; that’s ok.
The idea is to avoid a situation where I am typing away at code for hours, only to find
that what I created doesn’t work and I have no idea why. Try to find a middle ground,
and get to results I can see within a relatively short amount of time.
If I iterate like this for a long time and don’t seem to be getting anywhere, maybe it’s
time to start back at step one and try something different. But if I can get something to
work, even if it’s not exactly what I had in mind, now’s a good time to move on to the
next step.

Test your solution

Often, we do this by hand: load a web page and check that it contains all the elements
we expect it to render. Try replicating the conditions that led to a bug, and confirm
that the bug no longer happens. Try using the feature we added in a few different
ways and see what happens.
 Another way we do this is with automated tests. Adding a test that asserts a feature
works as predicted or a bug no longer occurs helps prevent unexpected problems
down the line.
Test-driven development is an alternate approach that starts with this step rather than
leaving it to the end. For each change I make to our project, I start by writing a test
that asserts the change will work as predicted, then make the change.
One advantage to the test-driven approach is that it forces you to think about what
success means before I start working on a given section of the project. This is a good
question to ask myself whether I start by writing a test, write one at the end, or verify
our change worked by some other means. It's part of the first step defined here—
identify and understand the problem—because it's so fundamental to finding a
solution.
Even if I am writing automated tests before I add any program code, I'll be checking
that a given portion of work satisfies what I am trying to do: running the test suite, and
trying the feature to make sure it works as expected.

Some Other problems and solution

1. Globalization causing extremely high competition
If your business is in the software industry and has a great idea, odds are another software
company may have ready thought of it; if not, there may be no away to determine how close
another company is to developing it. Time to market pressures is a stressful reality in the
software industry. Competition can be local or international and impact software companies
in terms of pricing structures, customer reach, customer retention, service level agreements
and a host of other factors.
Project managers will need to work closely with business owners, executives and other
stakeholders to flush out all factors that may impact the successfulness of software related
projects. There have been many software companies that have developed and implemented
terrific software only to find the return on their investment was simply not there due to high
competition.
2. Legacy systems and infrastructure issues
Often businesses have invested significant financial and human resources implementing,
enhancing, maintaining and patching older legacy systems and infrastructures. As a result,
there may be great reluctance to replace them, even if these systems no longer meet their
needs, creating a scenario where it is an uphill battle for innovative software companies to
get their foot in the door, even though they have a top-notch solution that businesses can
greatly benefit from.
If and when they do manage to convey the benefits to a company and are successful, project
managers typically still have an uphill battle working with various stakeholders who are
personally vested in older legacy systems and infrastructure, making them change resistant.
In order to gain buy-in, it is critical for project managers to be able to clearly convey all
benefits to stakeholders and find ways to alleviate their fears.
3. Sufficient software specific expertise
The software selection process can be time-consuming and tedious for business owners
and executives, and when it comes to implementations, finding project management
professionals with the relevant experience can be just as difficult, whether in-house or
outsourced. While there are general systems project implementation skill sets, it may be
necessary in most cases, especially when it comes to large ERP implementations, to seek
project managers who are highly experienced implementing those specific systems. As a
general rule, the more complex the system, project implementation, and the larger the
organization, the more likely direct system related project implementation experience will be
required.
4. SaaS offerings taking over
With increasing frequency, older legacy systems and large ERP systems are being replaced
with Saas offerings, enabling small, mid-siz and large businesses to access the same or
better features and capabilities without outlaying large amounts of valuable
capital. Companies are subscribing to this model because they are able to redirect larger
amounts of capital towards other projects that may be more value added to the overall
business strategy. They are able to instead allocate operating funds towards outsourced
monthly SaaS offerings that provide what they need and are more scalable and flexible.
Additionally, they no longer need to account for and deal with depreciation issues. It also
may be more cost-effective and more efficient to have an outside vendor take care of
maintenance and service-related requests that companies otherwise would have to hire
additional staff for. Often times project managers work for these outsourced SaaS vendors
and are highly experienced in implementations with that exact type of software, taking a lot
of pressure off of the company’s leadership. That said, the business strategy, project
alignment, and other due diligence still remains a responsibility of the leadership.

Some tools we used for testing

Jenkins
Jenkins is an open source automation tool written in Java with plugins built for Continuous
Integration purpose. Jenkins is used to build and test your software projects continuously
making it easier for developers to integrate changes to the project and making it easier for
users to obtain a fresh build.
SonarQube
SonarQube is an open-source platform developed by SonarSource for continuous
inspection of code quality to perform automatic reviews with static analysis of code to detect
bugs, code smells, and security vulnerabilities on 20+ programming languages.

Some Screenshots of our tested application