Terms Software Developer in the Radar Wants To ‘solve’ Location Industry Should Know

New startup Radar has chosen area is a since quite a while ago ignored issue and requires an answer for open its maximum capacity. 

There are attempted and-trusted answers for most designer issues today. On the off chance that you need interchanges in your application, Twilio can place you in touch. On the off chance that you have to deal with installments, Swipe can put that through for you. For area, Radar's CEO contends, there's not been such an answer. 

"We're ten years into the cell phone time, yet constructing items and administrations with area is still too hard. We're building Radar to change this," says Nick Patrick, CEO and fellow benefactor of Radar. "Radar is the area stage for versatile applications. Our main goal is to help organizations gather, break down, and follow up on area information." 

Patrick is a previous representative of Foursquare, so he is very brave with the advantages and difficulties of building area based applications. Alongside kindred fellow benefactor Coby Berman, additionally a past Foursquare representative, the combine considered the troublesome and monotonous procedure of building the back-end framework for area administrations and vowed to settle it. 

By coordinating with the Radar SDK, designers can simply begin with setting up geofences, following passage and leave occasions, and utilizing the information to improve the experience for clients. 

You can begin with only three stages: 

Track clients. Add the SDK to your iOS and Android applications to begin following client areas with less than 10 lines of code. 

Make geofences. Make boundless geofences, speaking to spots or districts, by means of the dashboard, mass import, or the API. 

Get occasions. Get geofence section and leave occasions customer side or server-side by means of webhooks. On the other hand, send out occasions for investigation. 

Radar dispatches formally today however has joined a few clients pre-dispatch including Raise, Wine n Dine, and Via. A complementary plan is accessible for those hoping to give the administration a go, while a paid endeavor level is estimated in light of utilization and gives hands-on support. 

Giving some genuine feelings of serenity to those of us worried about security, all identifiable data is kept separate from the area information to build wellbeing. 

You can discover more data about Radar and how to begin with it here - www.softwaredevelopmentwork.blogspot.com.

Sofware Project Ideas for Students of Computer Science Doing BE/MCA/BCA/M.Tech . . . . . .

1.Business Performance Reporting 
2 Case Management for Government Agencies 
3 Classroom Management 
4 Clinical Trial Initiation and Management 
5 Competitive Analysis Web Site
6 Discussion Forum website
7 Disputed Invoice Management
8 Employee Training Scheduling and Materials
9 Equity Research Management
10 Integrated Marketing Campaign Tracking
11 Manufacturing Process Managements
12 Product and Marketing Requirements Planning
13 Request for Proposal Software
14 Sports League Management
15 Absence Request and Vacation Schedule Management

 

16 Budgeting and Tracking Multiple Projects
17 Bug Database Management
18 Call Center Management Software
19 Change Request Management 
20 Compliance Process Support Site 
21 Contacts Management Software 
22 Document Library and Review 
23 Event Planning and Management 
24 Expense Reimbursement and Approval  
25 Help Desk and Ticket Management 
26 Inventory Tracking 
27 I T Team Workspace 
29 Job Requisition and Interview Management 
28 Knowledge Base 
29 Lending Library 
30 Physical Asset Tracking and Management 
31 Project Tracking Workspace 
32. Shopping Cart . 
33 Knowledge Base 
34 Lending Library 
35 Physical Asset Tracking and Management 
36 Project Tracking Workspace 
37 Room and Equipment Reservations 
38 Sales Lead Pipeline 
39. Yellow Pages & Business Directory
 40. Time & Billing 
41. Class Room Management 
42. Expense Report Database 
43. Sales Contact Management Database 
44. Inventory Management Database 
45. Issue Database 
46. Event Management Database 
47. Service Call Management Database 
48. Accounting Ledger Database 
49. Asset Tracking Database 
50. Cycle Factory Works Management 
51. Sales Corporation Management 
52. Business Directory 
53. Education Directory 
54. Dental Clinic Management 
55. Fund Raising Management 
56. Clinic/ Health Management 
57. Cable Management System 
58. Survey Creation and Analytics 
59. Museum Management System
60. Multi-Level Marketing System

61. Learning Management System
62. Knowledge Management System
63. Missing Person Site
64. Disaster Management Site
65. Job Management Site
66. Financial Portfolio Management
67. Market Research Management
68. Order Management System
69. Point of Sale
70. Advertisement /Banner Management and Analytics
71. Export Management System
72. Invoice Management
73. Recruitment Management System
74. Articles / Blog / Wiki Web site
75. Online Planner
76. Mock Tests and Examination Management
77. Examination System
78. Practice Test Management.
79. Asset Management System
80. Travel Agency System.
81. Placement Management System.
82. Polls Management
83. Customer Management
84. Project Management System.
85. Network Marketing System
86. Yoga Health Care Management
87. Personal Finance Management System
88. Real Estate Management System
89. Stock Mutual Funds Management 
90. Careers and Employment Management System 
91. Music Albums Management System 
92. Classified Ads Managements 
93. Property Management System 
94. Sales & Retail Management 
95. Dating Site 
96. Hotel Management System 
97. Search Engine 98. Online News Paper Site 
99. Image Gallery100. Staffing and Human Capital Management
101. Address Book
102. Inventory Management System
103. Newspaper Classifieds
104 Hostel Management
105 Music , Lyrics Website .
106 Wildlife Safari Trip Management

SOFTWARE DEVELOPMENT WORK : Project Management .

Some aspects of software development naturally relate to project management, especially when the software is only one part of a larger project.

SOFTWARE DEVELOPMENT WORK : Google launches new certification program for software development agencies

Google today announced a new certification program for development agencies.

The idea behind the program is to recognize agencies that “have undergone the required training and have demonstrated excellence in building Android applications,” a Google spokesperson tells us.

In total, 13 agencies in India, Russia, U.K. and U.S. have already been certified since Google first announced its plans for this program last December. These agencies work with both large enterprise clients and startups.

While Google notes that it does “not endorse, or offer any warranty, regarding the certified agencies,” the idea here is obviously to highlight some of the agencies that Google itself considers among the best in the ecosystem (and that use Google’s technologies, too). While the focus here is on Android apps, Google tells me that the program also includes support for agencies that work on web apps, too.

“The Agency Program is an effort by Google’s Developer Relations team to work closely with development agencies around the world and help them build high quality user experiences,” Google’s global lead for the agency program Uttam Kumar Tripathi writes today.

Google will provide certified agencies with personalized training, dedicated content, priority support and access to the company’s developer relations teams. Certified Agencies will also get early access to upcoming developer products and help with UX reviews.

SOFTWARE DEVELOPMENT WORK : How do I start doing contract work software development?

How do I get started doing contract work as a software developer, and how does it even work? I've 10 years of experience but I know nothing else but full time employment. Unless I get in the Valley, I don't think I will never be satisfied with my salary, and specially the amount of work and time required. Sounds selfish, but you need to understand I've been in leadership positions for the past 3 jobs and I don't seem to have a lot of room beyond that to see the unseen if I continue on this path. I work remotely so I might not be getting the full deal, but is the way that I prefer it and logistics will make it stay that way for a while. I wonder if switching to what appears to have more flexible times in contract work would at least take me to my current salary (~6k/mo) without spending at least so much time on it, as I assume rates tend to be much higher. If it would, how do I even get started? I've an active Github profile and know few freelancing sites (maybe even the wrong kind of sites), but other than that I've no idea where to begin. Pointers as well as experiences more than welcome. Thanks.

I never made it to 6k/mo before giving up on contracting. A few years ago I quite my job at Adobe in San Francisco to travel and thought I might as well try contracting while I'm at it. My logic was it would keep my skills fresh and if I didn't have work, hey, I can just enjoy the cool places I'm visiting that much more. A year ago I folded up the contracting business to just do my own thing... may my own "app"... 'cause I'm super original. :)  I consider it a failure, but the kind of failure one is supposed to have in life to prove that you're pushing yourself. So I'll give a few places why I failed, which won't 100% answer your questions, but kinda will. 

(1) Starting a new business is not a part time endeavor.
My plan to travel and build a contracting business in between was doomed from the start. One has to be dedicated and willing to work *extra* hours to build a successful business. 

(2) Contracting is about contacts. It can't be done well in isolation.
I was in Europe 9 hours ahead of my contacts in San Francisco and 6 ahead of those in NYC/Boston. This just generally makes business relationships hard. Meanwhile, friends who had quit their jobs to start their own company and stayed local were getting pounded with offers for contracting work. They were being seen. Often from fellow small businesses in the same co-working location. Or just friends of friends they get to talking with on weekends. You say you work remotely, too. I've found that there is a little lack of trust for remote workers, and there is also for contractors. Put the two together and no one wants to take a risk on you. 

(3) It's not so easy to cut out the middle man. 
Software Engineers can get contracted out to companies for roughly a bazillioooon dollars an hour. And we know this as well as the fact that we are the only ones *doing* any work for the client, so why can't we just make the bazillion ourselves? 

Ok, we don't simplify it that much. But that's roughly the idea when wanting to do your own contracting business. We also know that we engineers are smarter than your average middle manager, so we can do their jobs, too. No problem! 

In the end we underestimate how much time goes into finding clients, building relationships with them, answering their asinine questions, setting up the contract, so after all that the engineer can show up and do her thing. As well as refining your image as reliable, expert, valuable, and all that goes into branding a company. 

This crap will easily take half your time. And it's mostly not billable. 

(4) You need to attract a client who can afford you
One of my problems was I made no effort to all that mentioned above. I got all my jobs from a friend of a friend and these were mostly small companies. The work just found me, and that seemed cool. But software engineers are expensive. If I wanted to keep with it, I would get myself certified and set up to work as a government contractor (talk about bottomless pockets). The small clients who found me did not want to pay a software engineer rate. They couldn't pay that rate.

(5) No generalists welcome.
When someone hires a contractor they want an expert in X who will solve their immediate problem with X. I had a hard time with this. I'm a software engineer with a computer science degree and years of experience doing all kinds of software related work. I had always worked at big companies and I was used to being expected to learn a little for any project. I also had a "I can solve any problem" mindset. Clients don't want a generalist (in my experience, maybe a more successful contractor would have another opinion), they want a specialist. And you can'y be a specialist in 20 things. You get one or two. So, you have to pick. 

By contrast. I've recently gotten a bit of a reputation as a Web Designer -- which is kinda funny b/c I couldn't design my way out of a box. But I started throwing quick WordPress sites together for people I knew who needed a website (using lovely templates or "Themes"). These are real things that a person can see and understand. So clients tell their friends, "you need a webpage? Kait does webpages". As a general computer scientist / software engineer, I couldn't explain my abilities well enough that other people could sell for me. Having other people remember you and that you do X is so important b/c they remember and mention you when their friend talks about their problem with X. 

And even though I don't want contracting work now, I've started doing this on the side. But I would never make 6k/mo with that, these clients just can't pay that. But while I'm making 0k/mo working on my own projects, it's a nice bit of pocket change. 

Lessons learned.
So it was a failure, but I learned a lot. I was also reading and watching all I could on business at the time, which is handy now that I have a new business. Lynda is my favorite recourse: lynda.com library | Trial Subscription

You actual questions.
No, I don't think freelancing/contracting is a good way to make more money than you are now or about the same with less time.

No, contracting isn't really more "flexible". It's true as a contractor I didn't have to work any set hours. But I always had to reply to emails. It was more like being on call 24/7. The work and the threat of work never go away. I often had no work, but at the same time I couldn't confidently plan a vacation. A client could have an emergency at any time. And even more likely, after not having any work for weeks, suddenly this new job needs to be done NOW NOW NOW and I have to work crazy hours for weeks. During those weeks, I've no time to look for other clients, so as soon as this job is done, work's dry again. 

Freelancing sites are mostly crowd sourcing. You may not feel like a commodity with your 10 years experience, but you will when you see kids, and people in other countries, and even experienced developers bidding on programming jobs for $7/hour. Seven! I made more than that as a lifeguard in high school. 

Again, if I wanted to keep at it, I would go the government contracting route. All the info for that is at The U.S. Small Business Administration (SBA dot GOV).

Summary
Again, I was a failure. I have to assume there are people who do this more successfully and they would probably give you a more positive answer. But I don't think I've even ever met a one-person-shop contractor making over 6k/mo. I think the only way to do that (especially working short hours, like you want) is to be the world renowned expert on some specific thing. And those I think are mostly old retired dudes who are the last left who still know X legacy technology. If you're making that money working from home now, I don't know of any way to get a situation significantly more comfy and flexible. Definitely not an easy way.

Best of luck ! ! ! ! ! ! ! ! !

SOFTWARE DEVELOPMENT WORK : 5 things to know about software development in 2016

Get the O'Reilly Programming Newsletter and get week after week programming news and bits of knowledge from industry insiders. The accompanying piece was initially distributed in the Programming pamphlet. 

Know every one of the things? No chance! Here's the vital stuff. 

What number of programming engineers are there? Millions! What's more, I'm speculating you are one in the event that you are understanding this. Indeed, the precarious part about picking five things to concentrate on is that there are such a variety of various types of you chipping away at such a large number of various activities, from versatile applications, to executioner databases and IOT devices, to huge base. What you'll read here is my thought on the things that are changing being a piece of programming advancement. Appreciate the accompanying and let me realize what else you believe will be imperative in 2016. 

1. Flexible and secluded structures pick up force 

Might I venture to solicit, have you gotten notification from microservices? (If not, Martin Fowler separates it for you.) Some parents believe that it's only another name for administration arranged designs (not I). No more should programming models be solid structures that should be fixed and constructed onto at your risk. Microservices separate your engineering into littler, free applications that can be consistently updated, changed out, and enhanced. Case in point, when one bit of your framework is being saddled, you can concentrate on shoring up its execution while alternate pieces relax. Presently, microservices are not the answer for each situation. I anticipate that the stone monument will be around for quite a while, as it can be the right approach. In any case, this year, it is particularly justified regardless of your opportunity to look at if microservices bode well for your organization. 

O'REILLY SOFTWARE ARCHITECTURE CONFERENCE 2016 


Look at Building Microservices and The Principles of Microservices for some direction from Sam Newman or in the event that you are simply beginning, come to Mark Richards' Software Architecture: From Developer to Architect Training. 

2. The consistent conveyance and organization transformation proceeds 

Some individuals trust that microservices are the primary "DevOps" engineering. I concur, however the upheaval of DevOps goes a long ways past another design. It has been and will keep on being a distinct advantage for everybody who creates programming, from framework chairmen to programming engineers. From Chef to Kubernetes, a pack of new instruments to discharge, screen, and enhance programming applications has landed. Furthermore, if shipping programming early and frequently is the new typical, then everybody from the group pioneer to the discharge designer is influenced. Truth be told, the line amongst improvement and operations has viably been smirched to the point of being indistinguishable. In my perspective, this is all extraordinary news—programming doesn't need to be static, it can proceed to enhance (and is even anticipated that would) and there is a framework set up to make it so. What used to be a popular expression—DevOps—is presently a reality, though one that is as yet being tuned and refined. On the off chance that you haven't as of now, investigate what this implies for how your group is organized and how you can pick the best apparatuses for you. 

Look at Effective DevOps, Kubernetes: Up and Running, and Programming for SysAdmins. 

3. Programming advancement impacts the whole organization 

Programming designers do as such a great deal more than create programming. They can be in charge of numerous things: 

• Understanding client needs 
• Producing income by means of application deals 
• Making the substance of the organization by means of a site 
• Encouraging conveyance of substance to a great many people 
• Keeping characters safe 
• Ensuring equipment works each time 

I could go on, however the fact I'm making here is not that you are the focal point of the world, yet that your work is fundamental to basically everything your association does. Making programming of any sort goes a long ways past ensuring the ideal Python code gets composed (however that is basic!). It implies creating an item that takes care of an issue, answers a need, or encourages an administration. Understanding and adding to the outline, advancement, and sending of programming that really succeeds for clients is a great deal more included and intense than just written work code. Venture up to that administration position this year. 

Look at Hello, Startup and Beyond Blame for knowledge past coding. 

4. The consideration and encouraging of reasonable open source ventures 

Something I'll be contemplating this year is—the thing that happens now that open source has ended up pervasive? All product dialects, structures, and so forth are open source, so do we simply ease up on the gas? In the wake of talking with individuals who've been with open source subsequent to the starting, and in addition those new to it, plainly we can't simply say "Mission Accomplished." We have to keep on nourishing this group, characterize how both people and endeavors can best contribute and team up, and react to changes in the innovation environment that effect how open source programming is produced and kept up. 

Look at these free reports as a beginning spot for some great level headed discussion. 

5. Keep a decent adjust—The New Shiny versus Attempted and True 

Here at O'Reilly we get exceptionally energized and diverted now and again, in all honesty, with "The New Shiny." The possibility of a developing dialect, to me, is just so cool. I consider how it mirrors the universe of programming today like Java and others never could. 

On the other side, I want to consider how engineers manage legacy programming: when to update; considering if the COBOL code is alright as may be; and so forth. I was chatting with somebody as of late who said that NASA utilizes more seasoned programming design since, when you are floating past Pluto you either work or you don't—and well, we now have awesome pictures of Pluto. My point here—we will dependably have heaps of "New Shiny" methods, systems, dialects, and so on., yet bear in mind about the old standbys and how they can tackle your issues pretty much also, if worse, now and again.

software development india

If that comment seems a bit unusual, it is deliberate. What I want to do in this article is take a look at the relationship between programming and software design. For almost 10 years I have felt that the software industry collectively misses a subtle point about the difference between developing a software design and what a software design really is. I think there is a profound lesson in the growing popularity of C++ about what we can do to become better software engineers, if only we see it. This lesson is that programming is not about building software; programming is about designing software.
Years ago I was attending a seminar where the question came up of whether software development is an engineering discipline or not. While I do not remember the resulting discussion, I do remember how it catalyzed my own thinking that the software industry has created some false parallels with hardware engineering while missing some perfectly valid parallels. In essence, I concluded that we are not software engineers because we do not realize what a software design really is. I am even more convinced of that today.
The final goal of any engineering activity is the some type of documentation. When a design effort is complete, the design documentation is turned over to the manufacturing team. This is a completely different group with completely different skills from the design team. If the design documents truly represent a complete design, the manufacturing team can proceed to build the product. In fact, they can proceed to build lots of the product, all without any further intervention of the designers. After reviewing the software development life cycle as I understood it, I concluded that the only software documentation that actually seems to satisfy the criteria of an engineering design is the source code listings.
There are probably enough arguments both for and against this premise to fill numerous articles. This article assumes that final source code is the real software design and then examines some of the consequences of that assumption. I may not be able to prove that this point of view is correct, but I hope to shown that it does explain some of the observed facts of the software industry, including the popularity of C++.
There is one consequence of considering code as software design that completely overwhelms all others. It is so important and so obvious that it is a total blind spot for most software organizations. This is the fact that software is cheap to build. It does not qualify as inexpensive; it is so cheap it is almost free. If source code is a software design, then actually building software is done by compilers and linkers. We often refer to the process of compiling and linking a complete software system as "doing a build". The capital investment in software construction equipment is low -- all it really takes is a computer, an editor, a compiler, and a linker. Once a build environment is available, then actually doing a software build just takes a little time. Compiling a 50,000 line C++ program may seem to take forever, but how long would it take to build a hardware system that had a design of the same complexity as 50,000 lines of C++.

Another consequence of considering source code as software design is the fact that a software design is relatively easy to create, at least in the mechanical sense. Writing (i.e., designing) a typical software module of 50 to 100 lines of code is usually only a couple of day's effort (getting it fully debugged is another story, but more on that later). It is tempting to ask if there is any other engineering discipline that can produce designs of such complexity as software in such a short time, but first we have to figure out how to measure and compare complexity. Nevertheless, it is obvious that software designs get very large rather quickly.
Given that software designs are relatively easy to turn out, and essentially free to build, an unsurprising revelation is that software designs tend to be incredibly large and complex. This may seem obvious but the magnitude of the problem is often ignored. School projects often end up being several thousand lines of code. There are software products with 10,000 line designs that are given away by their designers. We have long since passed the point where simple software is of much interest. Typical commercial software products have designs that consist of hundreds of thousands of lines. Many software designs run into the millions. Additionally, software designs are almost always constantly evolving. While the current design may only be a few thousand lines of code, many times that may actually have been written over the life of the product.
While there are certainly examples of hardware designs that are arguably as complex as software designs, note two facts about modern hardware. One, complex hardware engineering efforts are not always as free of bugs as software critics would have us believe. Major microprocessors have been shipped with errors in their logic, bridges collapsed, dams broken, airliners fallen out of the sky, and thousands of automobiles and other consumer products have been recalled - all within recent memory and all the result of design errors. Second, complex hardware designs have correspondingly complex and expensive build phases. As a result, the ability to manufacture such systems limits the number of companies that produce truly complex hardware designs. No such limitations exist for software. There are hundreds of software organizations, and thousands of very complex software systems in existence. Both the number and the complexity are growing daily. This means that the software industry is not likely to find solutions to its problems by trying to emulate hardware developers. If anything, as CAD and CAM systems have helped hardware designers to create more and more complex designs, hardware engineering is becoming more and more like software development.
Designing software is an exercise in managing complexity. The complexity exits within the software design itself, within the software organization of the company, and within the industry as a whole. Software design is very similar to systems design. It can span multiple technologies and often involves multiple sub-disciplines. Software specifications tend to be fluid, and change rapidly and often, usually while the design process is still going on. Software development teams also tend to be fluid, likewise often changing in the middle of the design process. In many ways, software bears more resemblance to complex social or organic systems than to hardware. All of this makes software design a difficult and error prone process. None of this is original thinking, but almost 30 years after the software engineering revolution began, software development is still seen as an undisciplined art compared to other engineering professions.
The general consensus is that when real engineers get through with a design, no matter how complex, they are pretty sure it will work. They are also pretty sure it can be built using accepted construction techniques. In order for this to happen, hardware engineers spend a considerable amount of time validating and refining their designs. Consider a bridge design, for example. Before such a design is actually built the engineers do structural analysis; they build computer models and run simulations; they build scale models and test them in wind tunnels or other ways. In short, the designers do everything they could think of to make sure the design is a good design before it is built. The design of new airliner is even worse; for those, full scale prototypes must be built and test flown to validate the design predictions.
It seems obvious to most people that software designs do not go through the same rigorous engineering as hardware designs. However, if we consider source code as design, we see that software designers actually do a considerable amount of validating and refining their designs. Software designers do not call it engineering, however, we call it testing and debugging. Most people do not consider testing and debugging as real "engineering"; certainly not in the software business. The reason has more to do with the refusal of the software industry to accept code as design than with any real engineering difference. Mock-ups, prototypes, and bread-boards are actually an accepted part of other engineering disciplines. Software designers do not have or use more formal methods of validating their designs because of the simple economics of the software build cycle.

Revelation number two: it is cheaper and simpler to just build the design and test it than to do anything else. We do not care how many builds we do -- they cost next to nothing in terms of time and the resources used can be completely reclaimed later if we discard the build. Note that testing is not just concerned with getting the current design correct, it is part of the process of refining the design. Hardware engineers of complex systems often build models (or at least they visually render their designs using computer graphics). This allows them to get a "feel" for the design that is not possible by just reviewing the design itself. Building such a model is both impossible and unnecessary with a software design. We just build the product itself. Even if formal software proofs were as automatic as a compiler, we would still do build/test cycles. Ergo, formal proofs have never been of much practical interest to the software industry.
This is the reality of the software development process today. Ever more complex software designs are being created by an ever increasing number of people and organizations. These designs will be coded in some programming language and then validated and refined via the build/test cycle. The process is error prone and not particularly rigorous to begin with. The fact that a great many software developers do not want to believe that this is the way it works compounds the problem enormously.
Most current software development processes try to segregate the different phases of software design into separate pigeon-holes. The top level design must be completed and frozen before any code is written. Testing and debugging are necessary just to weed out the construction mistakes. In between are the programmers, the construction workers of the software industry. Many believe that if we could just get programmers to quit "hacking" and "build" the designs as given to them (and in the process, make fewer errors) then software development might mature into a true engineering discipline. Not likely to happen as long as the process ignores the engineering and economic realities.
For example, no other modern industry would tolerate a rework rate of over 100% in its manufacturing process. A construction worker who can not build it right the first time, most of the time, is soon out of a job. In software, even the smallest piece of code is likely to be revised or completely rewritten during testing and debugging. We accept this sort of refinement during a creative process like design, not as part of a manufacturing process. No one expects an engineer to create a perfect design the first time. Even if she does, it must still be put through the refinement process just to prove that it was perfect.
If we learn nothing else from Japanese management techniques, we should learn that it is counter-productive to blame the workers for errors in the process. Instead of continuing to force software development to conform to an incorrect process model, we need to revise the process so that it helps rather than hinders efforts to produce better software. This is the litmus test of "software engineering." Engineering is about how you do the process, not about whether the final design document needs a CAD system to produce it.
The overwhelming problem with software development is that everything is part of the design process. Coding is design, testing and debugging are part of design, and what we typically call software design is still part of design. Software may be cheap to build, but it is incredibly expensive to design. Software is so complex that there are plenty of different design aspects and their resulting design views. The problem is that all the different aspects interrelate (just like they do in hardware engineering). It would be nice if top level designers could ignore the details of module algorithm design. Likewise, it would be nice if programmers did not have to worry about top level design issues when designing the internal algorithms of a module. Unfortunately, the aspects of one design layer intrude into the others. The choice of algorithms for a given module can be as important to the overall success of the software system as any of the higher level design aspects. There is no hierarchy of importance among the different aspects of a software design. An incorrect design at the lowest module level can be as fatal as a mistake at the highest level. A software design must be complete and correct in all its aspects, or all software builds based on the design will be erroneous.
In order to deal with the complexity, software is designed in layers. When a programmer is worrying about the detailed design of one module, there are probably hundreds of other modules and thousands of other details that he can not possibly worry about at the same time. For example, there are important aspects of software design that do not fall cleanly into the categories of data structures and algorithms. Ideally, programmers should not have to worry about these other aspects of a design when designing code.
This is not how it works, however, and the reasons start to make sense. The software design is not complete until it has been coded and tested. Testing is a fundamental part of the design validation and refinement process. The high level structural design is not a complete software design; it is just a structural framework for the detailed design. We have very limited capabilities for rigorously validating a high level design. The detailed design will ultimately influence (or should be allowed to influence) the high level design at least as much as other factors. Refining all the aspects of a design is a process that should be happening throughout the design cycle. If any aspect of the design is frozen out of the refinement process, it is hardly surprising that the final design will be poor or even unworkable.
It would be nice if high level software design could be a more rigorous engineering process, but the real world of software systems is not rigorous. Software is too complex and it depends on too many other things. Maybe some hardware does not work quite the way the designers thought it did, or a library routine has an undocumented restriction. These are the kinds of problems that every software project encounters sooner or later. These are the kinds of problems discovered during testing (if we do a good job of testing), for the simple reason that there was no way to discover them earlier. When they are discovered, they force a change in the design. If we are lucky, the design changes are local. More often than not, the changes will ripple through some significant portion of the entire software design (Murphy's Law). When part of the effected design can not change for some reason, then the other parts of the design will have to be weakened to accommodate. This often results is what managers perceive as "hacking", but it is the reality of software development.
For example, I recently worked on a project where a timing dependency was discovered between the internals of module A and another module B. Unfortunately, the internals of module A were hidden behind an abstraction that did not permit any way to incorporate the invocation of module B in its proper sequence. Naturally, by the time the problem was discovered, it was much too late to try to change the abstraction of A. As expected, what happened was an increasingly complex set of "fixes" applied to the internal design of A. Before we finished installing version 1, there was the general feeling that the design was breaking down. Every new fix was likely to break some older fix. This is a normal software development project. Eventually, my colleagues and I argued for a change in the design, but we had to volunteer free overtime in order to get management to agree.
On any software project of typical size, problems like these are guaranteed to come up. Despite all attempts to prevent it, important details will be overlooked. This is the difference between craft and engineering. Experience can lead us in the right direction. This is craft. Experience will only take us so far into uncharted territory. Then we must take what we started with and make it better through a controlled process of refinement. This is engineering.
As just a small point, all programmers know that writing the software design documents after the code instead of before, produces much more accurate documents. The reason is now obvious. Only the final design, as reflected in code, is the only one refined during the build/test cycle. The probability of the initial design being unchanged during this cycle is inversely related to the number of modules and number of programmers on a project. It rapidly becomes indistinguishable from zero.
In software engineering, we desperately need good design at all levels. In particular, we need good top level design. The better the early design, the easier detailed design will be. Designers should use anything that helps. Structure charts, Booch diagrams, state tables, PDL, etc. -- if it helps, then use it. We must keep in mind, however, that these tools and notations are not a software design. Eventually, we have to create the real software design, and it will be in some programming language. Therefore, we should not be afraid to code our designs as we derive them. We simply must be willing to refine them as necessary.
There is as yet no design notation equally suited for use in both top level design and detailed design. Ultimately, the design will end up coded in some programming language. This means that top level design notations have to be translated into the target programming language before detailed design can begin. This translation step takes time and introduces errors. Rather than translate from a notation that may not map cleanly into the programming language of choice, programmers often go back to the requirements and redo the top level design, coding it as they go. This, too, is part of the reality of software development.
It is probably better to let the original designers write the original code, rather than have someone else translate a language independent design later. What we need is a unified design notation suitable for all levels of design. In other words, we need a programming language that is also suitable for capturing high level design concepts. This is where C++ comes in. C++ is a programming language suitable for real world projects that is also a more expressive software design language. C++ allows us to directly express high level information about design components. This makes it easier to produce the design, and easier to refine it later. With its stronger type checking, it also helps the process of detecting design errors. This results in a more robust design, in essence a better engineered design.
Ultimately, a software design must be represented in some programming language, and then validated and refined via a build/test cycle. Any pretense otherwise is just silliness. Consider what software development tools and techniques have gained popularity. Structured programming was considered a breakthrough in its time. Pascal popularized it and in turn became popular. Object oriented design is the new rage and C++ is at the heart of it. Now think about what has not worked. CASE tools? Popular, yes; universal, no. Structure charts? Same thing. Likewise, Warner-Orr diagrams, Booch diagrams, object diagrams, you name it. Each has its strengths, and a single fundamental weakness -- it really isn't a software design. In fact the only software design notation that can be called widespread is PDL, and what does that look like.
This says that the collective subconscious of the software industry instinctively knows that improvements in programming techniques and real world programming languages in particular are overwhelmingly more important than anything else in the software business. It also says that programmers are interested in design. When more expressive programming languages become available, software developers will adopt them.
Also consider how the process of software development is changing. Once upon a time we had the waterfall process. Now we talk of spiral development and rapid prototyping. While such techniques are often justified with terms like "risk abatement" and "shortened product delivery times", they are really just excuses to start coding earlier in the life cycle. This is good. This allows the build/test cycle to start validating and refining the design earlier. It also means that it is more likely that the software designers that developed the top level design are still around to do the detailed design.
As noted above -- engineering is more about how you do the process than it is about what the final product looks like. We in the software business are close to being engineers, but we need a couple of perceptual changes. Programming and the build/test cycle are central to the process of engineering software. We need to manage them as such. The economics of the build/test cycle, plus the fact that a software system can represent practically anything, makes it very unlikely that we will find any general purpose methods for validating a software design. We can improve this process, but we can not escape it.
One final point: the goal of any engineering design project is the production of some documentation. Obviously, the actual design documents are the most important, but they are not the only ones that must be produced. Someone is eventually expected to use the software. It is also likely that the system will have to be modified and enhanced at a later time. This means that auxiliary documentation is as important for a software project as it is for a hardware project. Ignoring for now users manuals, installation guides, and other documents not directly associated with the design process, there are still two important needs that must be solved with auxiliary design documents.
The first use of auxiliary documentation is to capture important information from the problem space that did not make it directly into the design. Software design involves inventing software concepts to model concepts in a problem space. This process requires developing an understanding of the problem space concepts. Usually this understanding will include information that does not directly end up being modeled in the software space, but which nevertheless helped the designer determine what the essential concepts were, and how best to model them. This information should be captured somewhere in case the model needs to be changed at a later time.
The second important need for auxiliary documentation is to document those aspects of the design that are difficult to extract directly from the design itself. These can include both high level and low level aspects. Many of these aspects are best depicted graphically. This makes them hard to include as comments in the source code. This is not an argument for a graphical software design notation instead of a programming language. This is no different from the need for textual descriptions to accompany the graphical design documents of hardware disciplines. Never forget that the source code determines what the actual design really is, not the auxiliary documentation. Ideally, software tools would be available that post processed a source code design and generated the auxiliary documentation. That may be too much to expect. The next best thing might be some tools that let programmers (or technical writers) extract specific information from the source code that can then be documented in some other way. Undoubtedly, keeping such documentation up to date manually is difficult. This is another argument for the need for more expressive programming languages. It is also an argument for keeping such auxiliary documentation to a minimum and keeping it as informal as possible until as late in the project as possible. Again, we could use some better tools, otherwise we end up falling back on pencil, paper, and chalk boards.
To summarize:
o Real software runs on computers. It is a sequence of ones and zeros that is stored on some magnetic media. It is not a program listing in C++ (or any other programming language).
o A program listing is a document that represents a software design. Compilers and linkers actually build software designs.
o Real software is incredibly cheap to build, and getting cheaper all the time as computers get faster.
o Real software is incredibly expensive to design. This is true because software is incredibly complex and because practically all the steps of a software project are part of the design process.
o Programming is a design activity -- a good software design process recognizes this and does not hesitate to code when coding makes sense.
o Coding actually makes sense more often than believed. Often the process of rendering the design in code will reveal oversights and the need for additional design effort. The earlier this occurs, the better the design will be.
o Since software is so cheap to build, formal engineering validation methods are not of much use in real world software development. It is easier and cheaper to just build the design and test it than to try to prove it.
o Testing and debugging are design activities -- they are the software equivalent of the design validation and refinement processes of other engineering disciplines. A good software design process recognizes this and does not try to short change the steps.
o There are other design activities -- call them top level design, module design, structural design, architectural design, or whatever. A good software design process recognizes this and deliberately includes the steps.
o All design activities interact. A good software design process recognizes this and allows the design to change, sometimes radically, as various design steps reveal the need.
o Many different software design notations are potentially useful -- as auxiliary documentation and as tools to help facilitate the design process. They are not a software design.
o Software development is still more a craft than an engineering discipline. This is primarily because of a lack of rigor in the critical processes of validating and improving a design.
o Ultimately, real advances in software development depend upon advances in programming techniques, which in turn mean advances in programming languages. C++ is such an advance. It has exploded in popularity because it is a mainstream programming language that directly supports better software design.
o C++ is a step in the right direction, but still more advances are needed.