Prototype Level

[Laylow Skidmore]

Ingeneral, a prototype is used to learn something. This might range from finding out if a mechanism is feasible to discovering if a feature set is meaningful to the market. Different levels of prototyping are appropriate at different stages of development and have different costs. We classify prototypes into four different levels, with higher-level prototypes typically being appropriate for the later phases of the product development process.

These principles apply to product prototype development of all sorts. For electronics products a prototype may exist to validate the embedded systems design or the enclosure design is viable. Or a prototype may exist for specific testing to validate the mechanical design.

Yes, using animation effects in Figma prototypes can add an extra layer of interactivity and realism to your designs. But I have a few doubts in mind, because applying complex animation on Figma can be very time-consuming, and the translation to the final product might differ across platforms or when handed off to developers.

Most of the Automated Driving Systems (ADS) technology development is targeting urban areas; there is still much to learn about how ADS will impact rural transportation. The DriveOhio team deployed level-3 ADS-equipped prototype vehicles in rural Ohio with the goal of discovering technical challenges for ADS deployment in such environments. However, before the deployment on public roads, it was essential to test the ADS-equipped vehicle for their safety limitations. At Transportation Research Center Inc. (TRC Inc.) proving grounds, we tested one such prototype system on a closed test track with soft targets and robotic platforms as surrogates for other road users. This paper presents an approach to safely conduct testing for ADS prototype and assess its readiness for public road deployment. The main goal of this testing was to identify a safe Operational Design Domain (ODD) of this system by gaining better understanding of the limitations of the system. The prototype system uses Apollo-based platform that provided perception, localization, routing, planning, and control modules. In this paper, we present a test matrix specifically designed for testing level-3 ADS-equipped vehicles on a closed test track. The test matrix includes a minimum set of test scenarios and procedures for each functionality of the ADS, for example, localization, routing, planning, object detection and collision avoidance, negotiating traffic at different types of intersections, car-following, etc. Various test parameters are chosen considering the intended public road deployment requirements and limitations. Further, we define safety metrics for various scenarios to objectively assess the limitations of the ADS. We also present sample data analysis results obtained from the testing. The ODD definitions were later used as ADS engagement/disengagement guidelines for the ADS operator to follow during public road deployment. The findings and lessons learned from this study will be useful in safely assessing limitations of future level-3 ADS-equipped prototypes.

This question is purely for learning and to step-up my technical understanding. I know there is no perfect solution and this question has possible never ending solution list but I think it's very important for every architect to understand the difference between demo and a live project.

I created many demo solutions in .Net in the past. I now have been assigned to architect and implement a production level web solution so I wanted to ask - on a very high level, what is required to convert a demo into a production level solution. From my understanding, this will require (other than functionally implementing clients' requirements):

I think the most important difference is that a prototype's objective is:

1. To prove that a problem can be solved in a certain way OR

2. Give client / management a feel of what the product would look and feel like

This is also because a prototype is usually a 'quick and dirty' project, thrown together without any of the considerations you've rightly pointed in your question (like testing, performance, security and a lot more).

So you'd be better off starting a new, proper project, than trying to make a bad project better.

Not all of those things are required, depending on your requirements, or there might be way more required. If you know what I mean ;) Unit testing and code coverage are good things, but depending on how you go about other parts of the process, might not be required. Some would say that more important than performance profiling is well-documented code, or a training manual. It varies!

By context and scope I mean - are you creating something to be used internally by a business? Customer-facing? Used by end-users? Is it in fact a jazzy version of Notepad, or a new RDBMS from scratch? What should be included will vary massively (massively!) by the project you are looking at.

By business requirements I don't mean the use-cases for the software, but the requirements of the project management / production process. If you insist you need all of those things for a production project, the cost will be reflected accordingly (very high). That could either mean it's over budget, late, or not even given the green light to start development.

It could be that more important than having a fixed set of criteria now is simply having a good production/development framework, high visibility and regular releases so quality can be assessed that way. It could be that no-one involved gives a crap about code coverage.

Interestingly, I think points 1, 2, 4 and 7 should already be done during the conception of your prototype, except that I don't think you should test every method in every class. Test the critical code, not whether get/set methods behave correctly.

Depending on the purpose of your application, where security is a big problem, point 6 may be critical enough that you need to achieve it in the prototype. Depending on the purpose of your application, where performance is the key, point 5 may be critical... You know what I mean. My opinion is that points 3, 5, and 6 may be necessary in the prototype if they are considered critical (point 8 is really valid for production applications)

Edit: it seems that my opinion differs completely from sJhonny's because I imply that I consider the prototype to be the basis/shell/skeleton of your future developments, so for me the prototype is not to be thrown away.

Quick-and-dirty "proof of concept" applications that get "cleaned up" and become production code. The "clean up" stage tends to either be a nightmare, or it is really a "sweep the problems under the rug" stage, resulting in massive technical debt.

"Mockup" prototypes or "wireframes". These can be paper-and-pencil UI sketches, or even interactive mockups done in a language where you can quickly throw this kind of stuff together without a whole lot of thought behind how it fits together. It should use fake data, no real architecture, etc. The point is that they give stakeholders an idea of what the system will be like, so that you can refine your requirements, but they CAN'T be used as part of your final solution.

I say build it like a project with no demo, but now you can include what you've learned from the demo in your design. Initial coding can be bad even once you start production. You're going to have to refactor much of it anyway.

The real problem to address is your time contraint. When the decision makers want you to continue working on the demo, they're under the impression that much of the application is ready, so it won't take as long. I've heard others use this logic on why they prefer to show sketches to clients instead of overly-realistic mockups. Pay attention to the demo code because it may have discovered issues you never thought of and probably didn't document in this process. You now have to consider them (Overly simplified, but yes, the database may not be accessible for example.).

All prototypes and demos are not created equal. The entire code could be worthless or certain parts may have been done very well. It doesn't matter if it is a demo you have to know the difference. You wouldn't just throw out a legacay app and start over would you? Forget I asked.

I'm currently toying with the idea of embarking on a project that far exceeds my current programming ability in a language I have very little real world experience in (C). Would it be valuable to prototype in a higher level language that I'm more familiar with (like Perl/Python/Ruby/C#) just so I can get the overall design going?

It is easier to optimize correct code than to correct optimized code. Premature optimization actually hinders optimization in the long run. Unnecessary optimization distorts designs, destroys modularity and information-hiding, and makes code much harder to modify. Latent bugs take longer to find. We often discover by profiling, or by changing machines or compilers, that we misjudged the computational effort of our code. Guess what? Now, optimization is much harder than it had to be.

It would not be valuable to do that, because a) the parts of those languages that translate directly to C would not be any simpler, and b) the parts that don't translate directly to C would be more difficult to rewrite in C than if you'd written them in C in the first place.

I was tasked with porting a game written in Java into Flash, AS3. On the surface, this has the potential to go relatively smoothly. After all, you could consider such a job to be more clear-cut than your average client work, because you've already got a completely built-out functional spec in the form of the source game. Java and AS 3 are both high level languages, and AS3 shares many traits in common with Java, such as package structures, single-inheritance/multiple-interface, (opt-in) strong typing, and notions of public/protected/private variable and function declarations. At the time I was still very green at Java, and completely new to the original source codebase. So I just dove in to see what I could find hoping that it would be quick and easy.

3a8082e126