research paper pseudo code

DEV Community

Posted on Apr 25, 2019 • Updated on Aug 26, 2019

Pseudo Code How To Write Pseudo-code

Have you ever had a really complex programming issue? An issue where you can probably write out the logic, but you aren't quite sure of the syntax you should use? Writing pseudo-code is a great place to start.

Pseudo-code is "language" where you can write all of your coding logic without writing one line of language-specific code. You see this a lot in algorithm research, especially machine learning algorithms. That doesn't mean you can't use it for web development.

Why you would use it

There are projects that are so massive that if you don't take the time to write a little pseudo-code, you could end up lost in a sea of implemented code. When you write some pseudo-code, it gives you a chance to really think through potential issues. You're able to look at pure logic and program flow without worrying about how your code runs.

Writing pseudo-code before you start typing real code will also help you finish your projects faster. Think of it as a blueprint. You know where everything needs to go and how everything works together. So when you get to the actual building phase, you don't have as much to think about because you've already thought through what you need to do.

The best part is that pseudo-code doesn't depend on any programming language. That logic you just wrote out can be taken by anyone and translated into their language of choice. It gives you the freedom to reuse and improve the architecture of the application that you're building.

One of the more subtle uses of pseudo-code is to share it with other people. Sometimes you'll have a specific piece of logic that can be used across multiple projects, but they are all in different programming languages. When you have the pseudo-code available, you can give it to other programmers and they can write that logic in whatever language they need to.

Another great feature is that you can write pseudo-code in any format you like. You could use the academic format. It's incredibly structured and detailed, but it tends to have a lot of math involved. Or you can write out a simple outline of what you expect your code to do.

How to write it

Here's an example of some pseudo-code I wrote in one of my academic papers:

I'll be the first to admit that this is probably overkill for web development. If you find yourself using LaTex to write your pseudo-code, you might be making it more complicated than you need to. Odds are strong that a quick little write up in Word or even Notepad will be sufficient.

Here's an example of some simple pseudo-code I wrote for one of my web development projects:

You don't have to be super technical with your pseudo-code, but typically the more detail you can pack into it the easier it is to write the actual code. Think about it like you're writing an outline for your program. It gives you a chance to really think through what you are trying to accomplish and you can see exactly how all of the code comes together.

The main things you need to focus on with pseudo-code are:

• The logical flow of your program
• The details of the complex parts of your program
• A consistent format

It really doesn't take much to write pseudo-code besides some hardcore thinking. As you write it, you'll start to see places where you could add more detail or places where you can take away some detail. Remember, this is mainly for your use so write it in a way that makes sense to you.

Personally, I love pseudo-code. It helps me keep my train of thought clear when I start typing the real code. When you have all of your logic already planned out, you get so much more time to experiment with performance and optimization. On top of that, you don't have to think as hard when you're deep into the code writing (yay for planned laziness).

What do you think? Do you think pseudo-code is worth the time or would you rather just jump into the code?

Hey! You should follow me on Twitter because reasons: https://twitter.com/FlippedCoding

Top comments (23)

Templates let you quickly answer FAQs or store snippets for re-use.

• Location Québec, Canada
• Work Back-end developper at ixmedia
• Joined Aug 27, 2018

I usually write pseudo code first, then I code around it. The pseudo code becomes basic comments for my actual code.

I also make a simplified version with checkboxes that I put on our task manager for my superiors to see. They can then understand where I'm going with this task.

Great article !

• Location Kuala Lumpur
• Education Selfthough from online study
• Work Dev Analys at Consultancy.co
• Joined Nov 8, 2019

Can share some example?

• Education B.S in Psychology
• Joined Mar 15, 2019

I love reading your posts. I'm newer to programming and I appreciate how you cover a lot of things that aren't brought up in tutorials. I think pseudo-code is something I need to get in the habit of doing more. Especially if I step away from a project for awhile and come back to it.

• Joined Apr 15, 2019

As mentioned in another comment, I write my pseudo code as comments in my script / program and fill it in Afterwards.

So you know what you thought at this moment even a few years later.

And another people will understand what you did too :)

• Location Under a rock somewhere
• Work Senior Software Engineer / Random Tech Enthusiast
• Joined Jun 11, 2018

Thanks! I'm glad my posts are actually useful! 😊

• Location Rosario, Argentina
• Joined Feb 22, 2017

I've been coding for about a year and a half, and today I bumped into a really complex task at work, which involved (as usual) reading another coworker's code. Luckily, I had read this post on my lunch time, and it really helped me to better understand the existing codebase (since I was able to grasp the logic behind the problem by using pseudo code). Thank you for sharing!

• Location Montreal, QC
• Education Lighthouse Labs Grad, '20
• Work Full Stack Developer
• Joined Mar 28, 2019

I'm just new to coding and I love this approach. Thank you for this post!

I also think the academic pseudo-code is interesting

Thank you! I'm glad it's helpful.

• Joined May 14, 2018

Pseudo-code is a great tool for working with large code bases that you didnt write in the first place, especially if they are complex. Or your own, 6 months later after you've moved on! As a senior I'll often tell younger devs to pseudo-code a task and bring it back to me before writing code; if their pseudo-code is correct I know they understand the problem and have much higher confidence they will write correct code.

• Location Europe
• Joined Oct 28, 2018

Yeah, but why not let them write real code and do a code review soon. It might cause a bit more work for you but it is safer and the junior will probably learn more. Coding is not like building a house. Code can easily be modified. Version management tools exist. Refactoring exists.

• Location Los Angeles
• Work Director, Web Development / Marketing
• Joined Aug 25, 2018

Different level of abstraction which allows for ultra efficient communication and review of logic.

I completely disagree.

Pseudocode might have made sense in the age of assembler, FORTRAN and C programming but nowadays the two main reasons for using it are probably:

Not mastering your programming language.

Not knowing about refactoring - nobody gets a non trivial task right at the first try. Code is not something you write once and never change it afterwards. But that's not a bad thing: Changing code is cheap if the code is clean.

Maybe there are some rare occasions where pseudocode does make sense but in most cases there are better tools to use when you are not yet ready to code: Draw diagrams write specification documents, talk to people, build a prototype, write unit tests (TDD).

What sucks most about pseudocode is that it will not provide any feedback.

Why does this matter to me after all? Because I think that it is much more helpful in the long run to put your energy into the real code.

• Location U.S.A
• Work UI Architect at (Private)
• Joined Dec 26, 2018

Why did you bother posting academic pseudo code? It ruins the opportunity to share the article to someone who is learning

It's just there as another example of what pseudo-code can look like and just how complex it can be if you need it. 🙂

• Location Chiang Mai, Thailand
• Education Ohio State University
• Work Customer Success Engineer at Raisely
• Joined Apr 8, 2018

I see both sides here.

I appreciate seeing the more complex side, but complex pseudo-code isn’t the focus of the article, and presenting it as the first example makes the reader think the complex stuff is what pseudo-code -really- is— and that the simpler example is just “dumbed down”.

Maybe it would help if the examples were used in a different way? Like, “pseudo-code can be simple [example] or complex [example], but it’s overall goal is to...”

Thanks for the article! It answered a few questions I had 😊

• Location George, South Africa
• Education Honours in Historical Studies
• Work Intern
• Joined Mar 12, 2019

Hi, nice article but I'm a beginner and I know I should nail this habit in now. I'm doing a bootcamp and the exercises are getting a bit more challenging, when I try to write pseudo code, I get trapped by 2 things. 1) I come from a more academic background, lots of essay writing, and so my pseudo code never comes out in simple digestible chunks and 2) sometimes I am not even sure how I will need to do what I need to do and so I end up just jumping right in and playing around, I never go back to writing pseudo code and if I made any attempts if offers me no guidance, because I'm like learning on the go about what works and doesn't. Any advice on how to improve on this?

• Joined Jul 2, 2018

Yes, Pseudo-codes are exactly necessary initially as it would allow the team(s) to brainstorm broadly as opposed to jumping straight into code.....

• Joined Apr 25, 2019

I can barely remember the last time I had to write pseudo-code. Usually I did, when I had to write something really difficult to just imagine in my mind. Nowadays, the stuff I code are pretty simple

• Location Mozambique
• Education ELT - Eduardo Mondlane University
• Work I.T Manager at Tecnicol Mozambique
• Joined Oct 24, 2017

Love it. Clearly is the best way to approach an algorithmic problem

What makes you think so? Does real code really suck that much? If yes, shouldn't we better find out why that is so and try to do something against it?

Some comments may only be visible to logged-in visitors. Sign in to view all comments.

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

Marked UUIDs Pattern

Ricardo Medeiros - Jun 28

Top 10 React.js Tips and Tricks Everyone Should Know

Vishal Yadav - Jun 29

BPM_宏天低代码 - Jun 28

A Comparative Analysis of Alpine.js and ReactJS

Nwosa Tochukwu - Jun 28

We're a place where coders share, stay up-to-date and grow their careers.

Prompting with Pseudo-Code Instructions

Mayank Mishra , Prince Kumar , Riyaz Bhat , Rudra Murthy , Danish Contractor , Srikanth Tamilselvam

Export citation

• Preformatted

Markdown (Informal)

[Prompting with Pseudo-Code Instructions](https://aclanthology.org/2023.emnlp-main.939) (Mishra et al., EMNLP 2023)

• Prompting with Pseudo-Code Instructions (Mishra et al., EMNLP 2023)
• Mayank Mishra, Prince Kumar, Riyaz Bhat, Rudra Murthy, Danish Contractor, and Srikanth Tamilselvam. 2023. Prompting with Pseudo-Code Instructions . In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing , pages 15178–15197, Singapore. Association for Computational Linguistics.

Pseudocode: What It Is and How to Write It

Pseudocode describes the distinct steps of an algorithm in a way that’s easy for anyone with to understand. Here’s how to write your own.

As developers and data scientists, we go through many stages, from getting an idea to reaching a valid, working implementation of it. We need to design and validate an  algorithm , apply it to the problem at hand and then test it for various input datasets.

What Is Pseudocode?

In the initial state of solving a problem , it helps to eliminate the limitations offered by a specific programming language’s syntax rules when we design or validate an algorithm. By doing this, we can focus our attention on the thought process behind the algorithm and how it will (or won’t) work instead of focusing on our syntax.

Here’s where pseudocode comes to the rescue.

We use pseudocode in various fields of programming, whether it be app development,  data science or web development. Pseudocode is a technique used to describe the distinct steps of an algorithm in a manner that’s easy to understand for anyone with basic programming knowledge . Although pseudocode is a syntax-free description of an algorithm, it must provide a full description of the algorithm’s logic so that moving from pseudocode to implementation is merely a task of translating each line into code using the syntax of any given programming language .

Clarify Your Code 5 Ways to Write More Pythonic Code

The Main Constructs of Pseudocode

At its core, pseudocode is the ability to represent six programming constructs (always written in uppercase): SEQUENCE, CASE, WHILE , REPEAT-UNTIL, FOR , and IF-THEN-ELSE. These constructs — also called keywords — are used to describe the control flow of the algorithm.

• SEQUENCE represents linear tasks sequentially performed one after the other.  
• WHILE is a loop with a condition at its beginning.  
• REPEAT-UNTIL is a loop with a condition at the bottom.  
• FOR is another way of looping.  
• IF-THEN-ELSE is a conditional statement changing the flow of the algorithm.  
• CASE is the generalization form of IF-THEN-ELSE.

Although these six constructs are the ones we use most often you can theoretically use them to implement any algorithm. You might find yourself needing more based on your specific application. Perhaps the two most needed commands are:

• Invoking classes or calling functions (using the CALL keyword).  
• Handling exceptions (using EXCEPTION, 5WHEN keywords).

Of course, based on the field you’re working in, you might add more constructs (keywords) to your pseudocode glossary as long as you never use these keywords as variable names and ensure they’re well-known within your field or company.

More from Sara A. Metwalli 5 Git Commands That Don’t Get Enough Hype

How to Write Pseudocode

When writing pseudocode, everyone has their own style of presenting since humans are reading it and not a computer; pseudocode’s rules are less rigorous than those of a programming language . However, there are some simple rules that help make pseudocode more universally understood.

• Always capitalize the initial word (often one of the main six constructs).
• Make only one statement per line.
• Indent to show hierarchy, improve readability and show nested constructs.
• Always end multi-line sections using any of the END keywords (ENDIF, ENDWHILE, etc.).
• Keep your statements programming language independent.
• Use the naming domain of the problem, not that of the implementation. For instance: “Append the last name to the first name” instead of “name = first+last.”
• Keep it simple, concise and readable.

Pseudocode Example

Following these rules helps you generate readable pseudocode and be able to recognize ones that aren’t well-written.  

Whether you’re a computer science major , went to bootcamp or took a programming class, you’ve probably heard of pseudocode before. When I teach my students pseudocode, at first, they don’t see the use of it; they think it’s a waste of time. As they put it, “Why write code twice?” That might be correct in the case of simple, straightforward problems. However, as the complexity and the size of the project increases, programmers come to realize how generating pseudocode makes writing the actual code much easier. Pseudocode helps you realize possible problems or design flaws in the algorithm earlier in the development stage, which saves you more time and effort on fixing bugs and avoiding errors down the road.

Be a Better Data Scientist 4 Data Science Portfolio Projects You Need to Create

Why Use Pseudocode?

Pseudocode is easier to read.

Often, programmers work alongside people from other fields such as mathematicians, managers and business partners. Using pseudocode to explain the mechanics of the code makes communicating between different specialties easier and more efficient.

Pseudocode Simplifies Code Construction

When the programmer goes through the process of developing and generating pseudocode converting that into real code written in any programming language will become much easier and faster.

Pseudocode Is a Good Middle Point Between Flowchart and Code

Moving directly from the idea to the flowchart to the code is not always a smooth ride. That’s where pseudocode presents a way to make the transition between the different stages somewhat simpler.

Pseudocode Is  a Helpful Starting Point for Documentation

Documentation is an essential aspect of building a good project but starting documentation is often the most difficult part of the process. Pseudocode can represent a good starting point for what the documentation should include. Sometimes, programmers even include the pseudocode as a docstring at the beginning of the code file.

Pseudocode Allows for Quick Bug Detection

Since pseudocode is written in a human-readable format, it is easier to edit and discover bugs before actually writing a single line of code. We can edit pseudocode more efficiently than testing , debugging and fixing actual code.

Pseudocode is an underestimated and under-utilized tool within the programming community, but a clear, concise, straightforward pseudocode can make a big difference on the road from idea to implementation — and a much smoother ride for the programmer.

Frequently Asked Questions

What is pseudocode.

Pseudocode is a representation of code used to demonstrate the implementation of an algorithm without actually doing so. It often acts as a rough draft of coding projects, and is written in an explainable manner to be understandable by programmers at any knowledge level.

How do you write a pseudocode?

Some general guidelines for writing pseudocode include the following:

• Make only one statement per line
• Capitalize the initial word of a line (which are often pseudocode constructs) 
• Use indentations to show hierarchy and nested constructs
• Use the naming domain of the problem, not of the implementation 
• Keep statements simple, readable and programming language independent  

At the same time, pseudocode writing style can vary for each programmer, so it may not always include these guidelines.

What is an example of pseudocode?

Consider an online store that offers discounts on orders of $50 or more. Following the principles of writing good pseudocode, the pseudocode for an algorithm determining if a user gets a discount could go as follows:

• Apply discount
• Display message: “Discount has been applied!”
• Do not apply discount 
• Display message: “Add more items to cart for discount!”

Recent Data Science Articles

IEEE Account

• Change Username/Password
• Update Address

Purchase Details

• Payment Options
• Order History
• View Purchased Documents

Profile Information

• Communications Preferences
• Profession and Education
• Technical Interests
• US & Canada: +1 800 678 4333
• Worldwide: +1 732 981 0060
• Contact & Support
• About IEEE Xplore
• Accessibility
• Terms of Use
• Nondiscrimination Policy
• Privacy & Opting Out of Cookies

A not-for-profit organization, IEEE is the world's largest technical professional organization dedicated to advancing technology for the benefit of humanity. © Copyright 2024 IEEE - All rights reserved. Use of this web site signifies your agreement to the terms and conditions.

A blog by Emmanuel Goossaert

How to implement an algorithm from a scientific paper

This article is a short guide to implementing an algorithm from a scientific paper. I have implemented many complex algorithms from books and scientific publications, and this article sums up what I have learned while searching, reading, coding and debugging. This is obviously limited to publications in domains related to the field of Computer Science. Nevertheless, you should be able to apply the guidelines and good practices presented below to any kind of paper or implementation.

To receive a notification email every time a new article is posted on Code Capsule, you can subscribe to the newsletter by filling up the form at the top right corner of the blog. As usual, comments are open at the bottom of this post, and I am always happy to welcome questions, corrections and contributions!

1 – Before you jump in

There are a few points you should review before you jump into reading a technical paper and implementing it. Make sure you cover them carefully each time you are about to start working on such a project.

1.1 – Find an open source implementation to avoid coding it

Unless you want to implement the paper for the purpose of learning more about the field, you have no need to implement it. Indeed, what you want is not coding the paper, but just the code that implements the paper. So before you start anything, you should spend a couple of days trying to find an open source implementation on the internet. Just think about it: would you rather lose two days looking for the code, or waste two months implementing an algorithm that was already available?

1.2 – Find simpler ways to achieve your goal

Ask yourself what you are trying to do, and if simpler solutions would work for what you need. Could you use another technique – even if the result is only 80% of what you want – that does not require to implement the paper, and that you could get running within the next two days or so with available open source libraries? For more regarding this, see my article The 20 / 80 Productivity Rule .

1.3 – Beware of software patents

If you are in the U.S., beware of software patents. Some papers are patented and you could get into trouble for using them in commercial applications.

1.4 – Learn more about the field of the paper

If you are reading a paper about the use of Support Vector Machines (SVM) in the context of Computational Neuroscience, then you should read a short introduction to Machine Learning and the different types of classifiers that could be alternatives to SVM, and you should as well read general articles about Computational Neuroscience to know what is being done in research right now.

1.5 – Stay motivated

If you have never implemented a paper and/or if you are new to the domain of the paper, then the reading can be very difficult. Whatever happens, do not let the amount and the complexity of the mathematical equations discourage you. Moreover, speed is not an issue: even if you feel that you understand the paper slower than you wish you would, just keep on working, and you will see that you will slowly and steadily understand the concepts presented in the paper, and pass all difficulties one after the other.

2 – Three kinds of papers

It is never a good idea to pick a random paper and start implementing in right away. There are a lot of papers out there, which means there is a lot of garbage. All publications can fit into three categories:

2.1 – The groundbreaking paper

Some really interesting, well-written, and original research. Most of these papers are coming out of top-tier universities, or out of research teams in smaller universities that have been tackling the problem for about six to ten years. The later is easy to spot: they reference their own publications in the papers, showing that they have been on the problem for some time now, and that they base their new work on a proven record of publications. Also, the groundbreaking papers are generally published in the best journals in the field.

2.2 – The copycat paper

Some research group that is just following the work of the groundbreaking teams, proposing improvements to it, and publishing their results of the improvements. Many of these papers lack proper statistical analysis and wrongly conclude that the improvements are really beating the original algorithm. Most of the time, they really are not bringing anything except for unnecessary additional complexity. But not all copycats are bad. Some are good, but it’s rare.

2.3 – The garbage paper

Some researchers really don’t know what they are doing and/or are evil. They just try to maintain their status and privileges in the academic institution at which they teach. So they need funding, and for that they need to publish, something, anything. The honest ones will tell you in the conclusion that they failed and that the results are accurate only N% of the time (with N being a bad value). But some evil ones will lie, and say that their research was a great success. After some time reading publications, it becomes easy to spot the garbage paper and ditch them.

Join my email list

3 – how to read a scientific paper.

A lot has already been written on the topic, so I am not going to write much about it. A good starting point is: How to Read a Paper by Srinivasan Keshav. Below are a few points that I found useful while I was reading scientific publications.

3.1 – Find the right paper

What you want to implement is an original paper, one that started a whole domain. It is sometimes okay to pick a copycat paper, if you feel that it brings real improvements and consistency to a good but immature groundbreaking paper.

So let’s say you have a paper as your starting point. You need to do some research in its surroundings. For that, the strategy is to look for related publications, and for the publications being listed in the “References” section at the end of the paper. Go on Google Scholar and search for the titles and the authors. Does any of the papers you found do a better job than the paper you had originally? If yes, then just ditch the paper you were looking at in the first place, and keep the new one you found. Another cool feature of Google Scholar is that you can find papers that cite a given paper. This is really great, because all you have to do is to follow the chain of citations from one paper to the next, and you will find the most recent papers in the field. Finding the good paper from a starting point is all about looking for papers being cited by the current paper, and for papers citing the current paper. By moving back and forth in time you should find the paper that is both of high quality and fits your needs.

Important: note that at this stage of simple exploration and reckoning, you should not be reading and fully understand the papers. This search for the right paper should be done just by skimming over the papers and using your instinct to detect the garbage (this comes with experience).

3.2 – Do not read on the screen

Print the publication on hard paper and read the paper version. Also, do not reduce the size in order to print more on each page. Yes, you will save three sheets of paper, but you will lose time as you will get tired faster reading these tiny characters. Good font size for reading is between 11 and 13 points.

3.3 – Good timing and location

Do not read a paper in the middle of the night, do it at a moment of the day when your brain is still fresh. Also, find a quiet area, and use good lighting. When I read, I have a desk lamp pointing directly at the document.

3.4 – Marker and notes

Highlight the important information with a marker, and take notes in the margin of whatever idea that pops in your head as you read.

3.5 – Know the definitions of all the terms

When you are used to read mostly news articles and fiction, your brain is trained to fill-in meaning for words that you do not know, by using context as a deduction device. Reading scientific publications is a different exercise, and one of the biggest mistake is to assume false meaning for a word. For instance in this sentence “The results of this segmentation approach still suffer from blurring artifacts”. Here two words, “segmentation”, and “artifacts”, have a general meaning in English, but also have a particular meaning in the domain of Computer Vision. If you do not know that these words have a particular meaning in this paper, then while reading without paying attention, your brain will fill-in the general meaning, and you might be missing some very important information. Therefore you must (i) avoid assumptions about words, and whenever in doubt look up the word in the context of the domain the publication was written, and (ii) write a glossary on a piece of paper of all the concepts and vocabulary specific to the publication that you did not know before. If you encounter for the first time concepts such as “faducial points” and “piece-wise affine transform”, then you should look-up their precise definitions and write them down in your glossary. Concepts are language-enabled brain shortcuts, and allow you to understand the intent of the authors faster.

3.6 – Look for statistical analysis in the conclusion

If the authors present only one curve from their algorithm and one curve from another algorithm, and say “look, it’s 20% more accurate”, then you know you’re reading garbage. What you want to read is: “Over a testing set of N instances, our algorithm shows significant improvement with a p-value of 5% using a two-sample t-test.” The use of statistical analysis shows a minimum of driving from the author, and is a good proof that the results can be trusted for generalization (unless the authors lied to make their results look more sexy, which can always happen).

3.7 – Make sure the conclusions are demonstrating that the paper is doing what you need

Let’s say you want an algorithm that can find any face in a picture. The authors of the paper say in the conclusion that their model was trained using 10 poses from 80 different people (10 x 80 = 800 pictures), and that the accuracy of face detection with the training set was 98%, but was only 70% with the testing set (picture not used during training). What does this mean? This means that apparently, the algorithm has issues to generalize properly. It performs well when used on the training set (which is useless), and perform worse when used in real-world cases. What you should conclude at this point is that maybe, this paper is not good enough for what you need.

3.8 – Pay attention to the input data used by the authors

If you want to perform face detection with a webcam, and the authors have used pictures taken with a high-definition camera, then there are chances that the algorithm will not perform as well in your case as it did for the authors. Make sure that the algorithm was tested on data similar to yours or you will end up with a great implementation that is completely unusable in your real-world setup.

3.9 – Authors are humans

The authors are humans, and therefore they make mistakes. Do not assume that the authors are absolutely right, and in case an equation is really hard to understand or follow, you should ask yourself whether or not the authors made a mistake there. This could just be a typo in the paper, or an error in the maths. Either case, the best way to find out is to roll out the equations yourself, and try to verify their results.

3.10 – Understand the variables and operators

The main task during the implementation of a publication is the translation of math equations in the paper into code and data. This means that before jumping into the code, you must understand 100% of the equations and processes on these equations. For instance, “C = A . B” could have different meaning. A and B could be simple numbers, and the “.” operator could simply be a product. In that case, C would be the product of two numbers A and B. But maybe that A and B are matrices, and that “.” represents the matrix product operator. In that case, C would be the product matrix of the matrices A and B. Yet another possibility is that A and B are matrices and that “.” is the term-by-term product operator. In that case, each element C(i,j) is the product of A(i,j) and B(i,j). Notations for variables and operators can change from one mathematical convention to another, and from one research group to another. Make sure you know what each variable is (scalar, vector, matrix or something else), and what every operator is doing on these variables.

3.11 – Understand the data flow

A paper is a succession of equations. Before you start coding, you must know how you will plug the output of equation N into the input of equation N+1.

4 – Prototyping

Once you have read and understood the paper, it’s time to create a prototype. This is a very important step and avoiding it can result in wasted time and resources. Implementing a complex algorithm in languages such as C, C++ or Java can be very time consuming. And even if you have some confidence in the paper and think the algorithm will work, there is still a chance that it won’t work at all. So you want to be able to code it as quickly as possible in the dirtiest way, just to check that it’s actually working.

4.1 – Prototyping solutions

The best solution for that is to use a higher level versatile language or environment such as Matlab, R, Octave or SciPy/NumPy. It is not that easy to represent a mathematical equation in C++ and then print the results to manually check them. On the contrary, it is extremely straightforward to write equations in Matlab, and then print them. What would take you two to three weeks in C++ will take take you two days in Matlab.

4.2 – Prototyping helps the debugging process

An advantage of having a prototype is that when you will have your C++ version, you will be able to debug by comparing the results between the Matlab prototype and the C++ implementation. This will be developed further in the “Debugging” section below.

4.3 – Wash-off implementation issues beforehand

You will certainly make software design mistakes in your prototype, and this is a good thing as you will be able to identify where are the difficulties with both the processes or data. When you will code the C++ version, you will know how to better architect the software, and you will produce way cleaner and more stable code than you would have without the prototyping step (this is the “throw-away system” idea presented by Frederick Brooks in The Mythical Man-Month ).

4.4 – Verify the results presented in the paper

Read the “Experiment” section of the paper carefully, and try to reproduce the experimental conditions as closely as possible, by using test data as similar as possible to the ones used by the authors. This increases your chances of reproducing the results obtained by the authors. Not using similar conditions can lead you to a behavior of your implementation that you might consider as an error, whereas you are just not feeding it with the correct data. As soon as you can reproduce the results based on similar data, then you can start testing it on different kinds of data.

5 – Choose the right language and libraries

At this stage, you must have a clear understanding of the algorithm and concepts presented in the publication, and you must have a running prototype which convinces that the algorithm is actually working on the input data you wish to use in production. It is now time to go into the next step, which consists in implementing the publication with the language and framework that you wish to use in production.

5.1 – Pre-existing systems

Many times, the production language and libraries are being dictated by pre-existing systems. For instance, you have a set of algorithm for illumination normalization in a picture, in a library coded in Java, and you want to add a new algorithm from a publication. In that case, obviously, you are not going to code this new algorithm in C++, but in Java.

5.2 – Predicted future uses of the implementation

In the case there is no pre-existing system imposing you a language, then the choice of the language should be done based upon the predicted uses of the algorithm. For example, if you believe that within four to six months, a possible port of your application will be done to the iPhone, then you should choose C/C++ over Java as it would be the only way to easily integrate the code into an Objective-C application without having to start everything from scratch.

5.3 – Available libraries that solve fully or partly the algorithm

The available libraries in different languages can also orient the choice of the production language. Let’s imagine that the algorithm you wish to implement makes use of well-known algebra techniques such as principal component analysis (PCA) and singular value decomposition (SVD). Then you could either code PCA and SVD from scratch, and if there is a bug could end up debugging for a week, or you could re-use a library that already implements these techniques and write the code of your implementation using the convention and Matrix class of this library. Ideally, you should be able to decompose your implementation into sub-tasks, and try to find libraries that already implement as many of these sub-tasks as possible. If you find the perfect set of libraries that are only available for a given language, then you should pick that language. Also, note that the choice of libraries should be a trade-off between re-using existing code and minimizing dependencies. Yes, it is good to have code for every sub-task needed for your implementation, but if that requires to create dependencies over 20 different libraries, then it might be not very practical and can even endanger the future stability of your implementation.

6 – Implementation

Here are some tips from my experience in implementing publications

6.1 – Choose the right precision

The type you will use for your computation should be chosen carefully. It is generally way better to use double instead of float . The memory usage can be larger, but the precision in the calculation will greatly improve, and is generally worth it. Also, you should be aware of the differences between 32-bit and 64-bit systems. Whenever you can, create your own type to encapsulate the underlying type (float or double, 32-bit or 64-bit), and use this type in your code. This can be done with a define is C/C++ or a class in Java.

6.2 – Document everything

Although it is true that over-documenting can slow down a project dramatically, in the case of the implementation of a complex technical paper, you want to comment everything. Even if you are the only person working on the project, you should document your files, classes and methods. Pick a convention like Doxygen or reStructuredText, and stick to it. Later in the development, there will be a moment where you will forget how some class works, or how you implemented some method, and you will thank yourself for documenting the code!

6.3 – Add references to the paper in your code

For every equation from the paper that you implement, you need to add a comment citing the paper (authors and year) and either the paragraph number or the equation number. That way, when later re-reading the code, you will be able to connect directly the code to precise locations in the paper. These comments should look like:

// See Cootes et al., 2001, Equation 2.3 // See Matthews and Baker, 2004, Section 4.1.2

6.4 – Avoid mathematical notations in your variable names

Let’s say that some quantity in the algorithm is a matrix denoted A. Later, the algorithm requires the gradient of the matrix over the two dimensions, denoted dA = (dA/dx, dA/dy). Then the name of the the variables should not be “dA_dx” and “dA_dy”, but “gradient_x” and “gradient_y”. Similarly, if an equation system requires a convergence test, then the variables should not be “prev_dA_dx” and “dA_dx”, but “error_previous” and “error_current”. Always name things for what physical quantity they represent, not whatever letter notation the authors of the paper used (e.g. “gradient_x” and not “dA_dx”), and always express the more specific to the less specific from left to right (e.g. “gradient_x” and not “x_gradient”).

6.5 – Do not optimize during the first pass

Leave all the optimization for later. As you can never be absolutely certain which part of your code will require optimization. Every time you see a possible optimization, add a comment and explain in a couple of lines how the optimization should be implemented, such as:

// OPTIMIZE HERE: computing the matrix one column at a time // and multiplying them directly could save memory

That way, you can later find all the locations in your code at which optimizations are possible, and you get fresh tips on how to optimize. Once your implementation will be done, you will be able to find where to optimize by running a profiler such as Valgrind or whatever is available in the programming language you use.

6.6 – Planning on creating an API?

If you plan on using your current code as a basis for an API that will grow with time, then you should be aware of techniques to create interfaces that are actually usable. For this, I would recommend the “coding against the library” technique, summarized by Joshua Bloch in his presentation How to Design a Good API and Why it Matters .

7 – Debugging

Implementing a new algorithm is like cooking a dish you never ate before. Even if it tastes kind of good, you will never know if this is what it was supposed to taste. Now we are lucky, since unlike for cooking, software development has some helpful trick to increase the confidence we have in an implementation.

7.1 – Compare results with other implementations

A good way to wash out the bugs is to compare the results of your code with the results of an existing implementation of the same algorithm. As I assume that you did correctly all the tasks in the “But before you jump” section presented above, you did not find any available implementation of the algorithm (or else you would have used it instead of implementing the paper!). As a consequence, the only other implementation that you have at this stage is the prototype that you programmed earlier.

The idea is therefore to compare the results of the prototype and the production implementation at every step of the algorithm. If the results are different, then one of the two implementations is doing something wrong, and you must find which and why. Precision can change (the prototype can give you x = 1.8966 and the production code x = 1.8965), and the comparison should of course take this into account.

7.2 – Talk with people who have read the paper

Once all the steps for both implementations (prototype and production) are giving the exact same results, you can gain some confidence that your code is bug free. However, there is still a risk that you made a mistake in your understanding of the paper. In that case, both implementations will give the same results for each step, and you will think that your implementations are good, whereas this just proves that both implementations are equally wrong. Unfortunately, there is no way that I know of to detect this kind of problems. Your best option is to find someone who has read the paper, and ask that person questions regarding the parts of the algorithm you are not sure about. You could even try to ask the authors, but your chances to get an answer are very low.

7.3 – Visualize your variables

While developing, it is always good to keep an eye on the content of the variables used by the algorithm. I am not talking about merely printing all the values in the matrices and data you have, but finding the visualization trick adapted to any variable in your implementation. For instance, if a matrix is suppose to represent the gradient of an image, then during the coding and debugging, you should have a window popping up and showing that gradient image, not just the number values in the image matrix. That way, you will associate actual an image with the data you are handling, and you will be capable of detecting when there is a problem with one of the variables, which in turn will indicate a possible bug. Inventive visualization tricks include images, scatter plots, graphs, or anything that is not just a stupid list of 1,000 numbers and upon which you can associate a mental image.

7.4 – Testing dataset

Generating data to experiment with your implementation can be very time consuming. Whenever you can, try to find databases (face database, text extract databases, etc.) or tools for generating such data. If there are none, then do not lose time generating 1000 samples manually. Code a quick data generator in 20 lines and get done with it.

In this article, I have presented good practices for the implementation of a scientific publication. Remember that these are only based on my personal experience, and that they should not be blindly followed word for word. Always pay attention when you read and code, and use your judgement to determine which of the guidelines presented above fit your project. Maybe some of the practices will hurt your project more than it will help it, and that’s up to you to find out.

How to Read a Paper by Srinivasan Keshav How to Design a Good API and Why it Matters by Joshua Bloch The Mythical Man-Month by Frederick Brooks The 20 / 80 Productivity Rule by Emmanuel Goossaert Google Scholar

• programming
• publication

43 Comments

Thanks to your article, I learned a lot.

I am glad to hear that this post can be useful. If you have any questions, feel free to ask 🙂

good article! will be really helpful..

Excellent read, thank you very much.

Don’t forget that it’s also possible to email the author, especially for recent papers. Odds are that they have an implementation lying around somewhere, and they’re usually happy to share it with you. (Often with the warning that it’s not very pretty code!)

I’ve usually found that research papers rarely include enough information to implement their algorithm. I come an electrical engineering background, and many of the papers in my research omit, either on purpose or accidentally, critical parts of their algorithm to be able to reproduce their results. A trite example is filter coefficients. What’s your experience with regards to complete algorithm documentation?

I have run into the issue you describe with Computer Science papers too, and it is very frustrating. It can also become catastrophic if you realize that some details are missing in the paper when you have already invested weeks of time in the implementation. This is why prototyping with Matlab or Python is so important, so that such situations can be detected as fast and as early as possible.

Very interesting sum up.

“single value decomposition (SVD)” It’s actually singular value decomposition.

Good catch, fixed. Thanks!

Nice article. As a writer of scientific papers, this has given me a lot of food for thought as to what would help the people who implement my algorithms – I’ll make sure I take these points on board in the future.

I am happy to hear my article can help. In my opinion, the best way you can help the readers of your papers is to provide them with actual code that implements your paper. That will give them a starting point and help them understand how the maths in your paper translate into code. But more important, it will give them something to code against, and in order to debug their implementation, they’ll only need to compare the outputs of their code with yours step by step. The code you give them doesn’t need to be all neat and clean, a rough prototype in any language you want is more than enough. Sadly, so few researchers share their code.

gone through the steps and love to apply it on a paper called ‘document summarization’. I know the paper is too complex for me however I’ll try your techniques to overcome the hurdle.

anyway thanks for writing it up.

Nice summary! I would add that it’s a great idea to simply contact the authors directly. Since they are the experts they may be able to provide insight or even code that could save you loads of time. Not all academicians are interested in applying their research but they certainly can be found in more applied fields such as as Human Factors or comp science. It’s almost always worth a shot.

Great article with some very helpful tips.

One important aspect of 5.3 Available Libraries is to pay attention to the license terms, particularly when the end goal is commercial and/or closed source software.

Even if your project is academic and open source, some license models do dictate your license terms, may conflict with other libraries you already use and limit how others can build on your work.

In my experience BSD and derivatives are the least headache where as GPL is pretty toxic for any commercial venture.

I have just submitted a paper to PLOS Computational Biology. I have tried to make my model available to the referees and readers. I wrote a JSim version ( http://physiome.org/jsim/ ) of the model ( http://goo.gl/WvPAf ). And I made two videos explaining how to use the (free) JSim software to run the model: http://www.youtube.com/watch?v=9TdNjG_1YAI http://www.youtube.com/watch?v=a9vVIHRZFyk

In my paper, I have given a complete derivation of my equations. I have my fingers crossed that the journal editor will allow that complete derivation to be published.

It seems that the web is opening avenues that will permit algorithms and models to be fully explained.

Don’t forget you could simply ask nicely the authors.

You could ask the authors, but I often find that many authors don’t like to make their new algorithms dirty by having to write actual implementations of them. You know, deal with real input data, handle corner cases and so on. Here’s my proofs, here’s my algorithm. Now you messy engineers go and do something with it.

Yes, exactly! Their clever proofs tend to ignore those messy corner cases that turn out to be central to the problem they’re supposed to have solved! 🙂

I like the pragmatic approach you advise and have two questions:

1. How do you establish what the top journals are in a particular field of C.S.? 2. Have you ever encountered a garbage article in a top journal?

A good paper would logically get, after some time, a lot of citations. Therefore by looking for the journals/conferences/institutions that have many papers with a lot citations, you’ll find the good ones. The Microsoft Academic Search website has a good tool for that, they have among other things a list of the top journals ranked by H-index and citations [1].

And then of course you can find poor quality papers in good journals. The peer-review process is not perfect, and there is also a lot of politics in the academic world. The best thing to do when reading a paper is to trust your gut. After some time reading papers, you get a good feeling of what to expect in terms of scientific method from the authors, and you will detect more easily when something is missing or just wrong in their approach.

[1] http://academic.research.microsoft.com/RankList?entitytype=4&topdomainid=2&subdomainid=0&last=0

Instead of search for original articles it is often a good idea to search for survey papers, or for textbooks about the topic. Often, the ideas in the original paper have been improved upon, and the survey will mention which of the improvements were actually found useful.

This avoids a not uncommon pitfall: you code something from a domain you’re not familiar with, and get disappointing results, then you meet somebody from that field who tells you “hey, but EVERYBODY knows that straight [algorithm] does not work in real life and that you should do [modification]”.

hi,tnx to your article . Im a beginner , and I have a question . How can I Find an open source implementation of the paper ? any specific source or any speacial search way ?

Thank you, thank you, thank you. I’ve been struggling for about six months, feeling my way around implementation of such a paper. Your insights validate my pain so far, and your approach to prototyping shall prove invaluable to verification when I am able to outsource the bulk of the code.

Great job!!!

Excellent article. Inspiring! Loved reading it:)

Great article, very informing. Thanks Emmanuel

It is a great post. I appreciate it.

I am the beginner, i want to know how to find the source code of a research paper?

Ya You are right. most of the time is wasted in fake papers,even now a days big publishers are supporting them.also some papers are only mathematical adventures.

I have implemented an algorithm for a given problem. After googling i found that the time complexity of that algorithm so far implemented is exponential O(2^n) . I implemented the same in linear time complexity O(n) with constant space. I coded it in java and compared the results with existing solutions . Mine is very faster than existing solutions. Could any one help me how to publish this? I am not a fresh graduate , done my graduation a dacade ago.

I guess if you have no connection to the academic world it will be hard to write and publish a publication. You should ask for help on some online communities, I would recommend that you try Reddit, maybe https://www.reddit.com/r/compsci/ or https://www.reddit.com/r/Programming . I hope this helped!

You found a linear time algorithm for a problem known to be O(2^n)? I’d say write a Letter to Communications of the ACM and collect your Turing prize 🙂

A very insightful and timely article. As an experienced researcher, I found some issues mentioned here, are common to all. We shall strive to implement some of the suggestions made here. Thanks Mr Emmanuel.

Thank-you for sharing what is truly exceptional advice! (In particular, I like your advice on variable-naming. It’s very tempting to just use symbols that appear in the literature, but doing so obscures the intent of the code!)

The process you describe here is exactly what I do in industry for a living. It’s difficult, time-consuming work, and you’ve explained each step perfectly. Nice job!

I’ve found that failing to do even one of these steps can potentially be disastrous! Yet, it’s astonishingly hard to convince project managers why each step is absolutely necessary in order to produce high quality software. Have you had any experience justifying these kinds of efforts to stakeholders of your projects?

A very good article to read and clearly, important guidelines have been given. As a starter in writing scientific papers, I feel grateful to you. Looking forward for the next article.

I always stuck in prototyping. It’s like I always procrastinate coding. I can easily read papers and summarize it. How to overcome this?

I’ve learnt a lot thanks. I’ve python programming language and tensorflow library background. Can you point me some easy papers to implement(I’v a little background in Maths – Basic calculus)?

I am currently puzzled by this scenario of implementing a research paper to investigate the authenticity of the algorithm. But the paper did not explain the algorithm nor present the pseudo code, just the result of their experiment. Should i abandon it or is there anything i can do?

Hello Nehemiah. It’s hard to say without knowing what paper you’re referring to, but my guess would be that it depends on your skills and ability to implement the algorithm based on the description from the authors, and how long it would take you to do so. If you estimate that it would take you from a few hours to a couple of days, then I’d say go for it. If it’s more, then it’s probably not worth your time and you’d be better off looking for other solutions that you could try out more easily. I hope that helps!

Please subscribe me

It’s very nice and helpful articles, as I am starting to learn machine learning and deep learning algorithms there are so many papers lying around and some times even they are written to tackle the same problem the math in them becomes very difficult to imagine and process. Loved the explanation and prototyping concept. Keep writing.

I am sick of every paper saying “We beat the state-of-the-art by margin X. ”

Thanks for your article, I am almost hopeless after reading every paper, start questioning myself if I am fit for the task. I always practice the DRY method when coding, so for every algorithm that i find, I usually add “github” behind, just to try my luck if there is any implementation of it, which, some of the time, I am lucky.

Maybe I am too rushy in getting things done, expect to code the solution in days, instead of months.

hi sir…..this article very nice and useful…..i have one doubts…..how to find the classic paper based on sementic and what are parameters….pls reply to my mail id …….

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Don't subscribe All new comments Replies to my comments Notify me of follow-up comments via e-mail. You can also subscribe without commenting.

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

What is suitable format to present a Psuedo Code in academic paper?

I'm going to include my algorithm as a pseudo-code in a double-column paper format.

However, since lines of my pseudo-code are long I don't know if is it suitable to use the width of both columns to demonstrate algorithm or not? I want to know are there any common rules for this?

This depends on the journal's author guidelines. If no specifics are stated, you can often add the pseudo-code like a figure in your text (just labeled with Algorithm 1 instead of Figure 1).

• 1 In addition, the publisher may use the set of parameters (indentations, linebreaks and line numbers, font size) to adjust the formatting of the code to match the width of a column. The publisher equally may decide that the pseudocode spans across two columns while the text of the publication is set in two columns (like as there are figures for single column [e.g., 8.85 cm], part-page width [e.g., 12 cm] or full-page width [e.g., 18 cm]). –  Buttonwood Commented Apr 9, 2020 at 10:35

You must log in to answer this question.

Not the answer you're looking for browse other questions tagged journals formatting ..

• Featured on Meta
• Upcoming sign-up experiments related to tags

Hot Network Questions

• How would I say the exclamation "What a [blank]" in Latin?
• How to determine if gravity is roughly linear?
• Why potential energy is not considered in the internal energy of diatomic molecules?
• How to "refresh" or "reset" the settings of a default view?
• Old book about a man who finds an abandoned house with a portal to another world
• Is Légal’s reported “psychological trick” considered fair play or unacceptable conduct under FIDE rules?
• Computations in coordinates of Hamiltonian vector fields
• How can a landlord receive rent in cash using western union
• Cleaning chain a few links at a time
• Can my IP be found on Telegram by malicious people?
• Are both vocal cord and vocal chord correct?
• Where can I access records of the 1947 Superman copyright trial?
• Does Matthew 7:13-14 contradict Luke 13:22-29?
• Correlation for Small Dataset?
• What kind of sequence is between an arithmetic and a geometric sequence?
• Can front gear be replaced on a Retrospec Judd folding bicycle?
• Is the zero vector necessary to do quantum mechanics?
• Rear shifter cable wont stay in anything but the highest gear
• How to bid a very strong hand with values in only 2 suits?
• Are there any CID episodes based on real-life events?
• How can I confirm for sure that a CVE has been mitigated on a RHEL system?
• "All due respect to jazz." - Does this mean the speaker likes it or dislikes it?
• Can I route audio from a macOS Safari PWA to specific speakers, different from my system default?
• How are "pursed" and "rounded" synonymous?

• PRO Courses Guides New Tech Help Pro Expert Videos About wikiHow Pro Upgrade Sign In
• EDIT Edit this Article
• EXPLORE Tech Help Pro About Us Random Article Quizzes Request a New Article Community Dashboard This Or That Game Popular Categories Arts and Entertainment Artwork Books Movies Computers and Electronics Computers Phone Skills Technology Hacks Health Men's Health Mental Health Women's Health Relationships Dating Love Relationship Issues Hobbies and Crafts Crafts Drawing Games Education & Communication Communication Skills Personal Development Studying Personal Care and Style Fashion Hair Care Personal Hygiene Youth Personal Care School Stuff Dating All Categories Arts and Entertainment Finance and Business Home and Garden Relationship Quizzes Cars & Other Vehicles Food and Entertaining Personal Care and Style Sports and Fitness Computers and Electronics Health Pets and Animals Travel Education & Communication Hobbies and Crafts Philosophy and Religion Work World Family Life Holidays and Traditions Relationships Youth
• Browse Articles
• Learn Something New
• Quizzes Hot
• This Or That Game
• Train Your Brain
• Explore More
• Support wikiHow
• About wikiHow
• Log in / Sign up
• Computers and Electronics
• Programming

Learn to Write Pseudocode: What It Is and Why You Need It

Last Updated: February 23, 2023 Fact Checked

Pseudocode Basics

Writing good pseudocode, creating an example pseudocode document.

This article was co-authored by wikiHow staff writer, Kyle Smith . Kyle Smith is a wikiHow Technology Writer, learning and sharing information about the latest technology. He has presented his research at multiple engineering conferences and is the writer and editor of hundreds of online electronics repair guides. Kyle received a BS in Industrial Engineering from Cal Poly, San Luis Obispo. This article has been fact-checked, ensuring the accuracy of any cited facts and confirming the authority of its sources. This article has been viewed 1,062,137 times. Learn more...

Want to learn how to write pseudocode? Pseudocode is a step-by-step written outline of your code that you can transcribe into the programming language you’re working with. In other words, you’re writing the flow of your code in plain language rather than official coding syntax. Many programmers use pseudocode to plan out the logic of an algorithm before writing it in code. This wikiHow shows you how to write a pseudocode document for your computer program.

Things You Should Know

• Pseudocode is useful for planning your program and troubleshooting the logic.
• Use a simple plain-text editor or even pen and paper to write your pseudocode.
• Write a statement for each line of logic in your program.

• Describing how an algorithm should work. Pseudocode can illustrate where a particular construct, mechanism, or technique could or must appear in a program.
• Explaining a computing process to less-technical users. Computers need a very strict input syntax to run a program, but humans (especially non-programmers) may find it easier to understand a more fluid, subjective language that clearly states the purpose of each line of code.
• Designing code in a group setting. High-level software architects will often include pseudocode in their design process to help solve a complex problem they see their programmers running into. If you are developing a program with other coders, you may find that pseudocode helps make your intentions clear.

Pseudocode serves as a guide for thinking through programming problems, and a communication option that can help you explain your ideas to other people.

• If you are working with others on a project—whether they are your peers, junior programmers, or non-technical collaborators—it is important to use at least some standard structures so that everyone else can easily understand your intent.
• If you are enrolled in a programming course at a university, a coding camp, or a company, you will likely be tested against a taught pseudocode "standard". This standard often varies between institutions and teachers.

Clarity is a primary goal of pseudocode, and it may help if you work within accepted programming conventions. As you develop your pseudocode into actual code, you will need to transcribe it into a programming language – so it can help to structure your outline with this in mind.

• You can use pen and paper to write your pseudocode! Try different formats to find what works best for your creative programming process.

Plain-text editors include Notepad (Windows) and TextEdit (Mac).

• For example, a section of pseudocode that discusses entering a number should all be in the same "block", while the next section (e.g., the section that discusses the output) should be in a different block.

• For example, if you use "if" and "then" commands in your pseudocode, you might want to change them to read "IF" and "THEN" (e.g., "IF <condition> THEN <output result>").

You might even want to get rid of any coding commands altogether and just define each line's process in plain language. For example, "if input is odd, output 'Y'" might become "if user enters an odd number, display 'Y'".

• This will make writing the actual code easier, since your code will run top-down.

• if CONDITION then INSTRUCTION — This means that a given instruction will only be conducted if a given condition is true. "Instruction", in this case, means a step that the program will perform, while "condition" means that the data must meet a certain set of criteria before the program takes action. [3] X Research source
• while CONDITION do INSTRUCTION — This means that the instruction should be repeated again and again until the condition is no longer true. [4] X Research source
• do INSTRUCTION while CONDITION — This is very similar to "while CONDITION do INSTRUCTION". In the first case, the condition is checked before the instruction is conducted, but in the second case the instruction will be conducted first; thus, in the second case, INSTRUCTION will be conducted at least one time.
• function NAME (ARGUMENTS): INSTRUCTION — This means that every time a certain name is used in the code, it is an abbreviation for a certain instruction. "Arguments" are lists of variables that you can use to clarify the instruction.

• Brackets—both square [code] and curly {code}—can help contain long segments of pseudocode.
• When coding, you can add comments by typing "//" on the left side of the comment (e.g., //This is a temporary step. ). You can use this same method when writing pseudocode to leave notes that don't fit into the coding text.

• Would this pseudocode be understood by someone who isn't familiar with the process?
• Is the pseudocode written in such a way that it will be easy to translate it into a computing language?
• Does the pseudocode describe the complete process without leaving anything out?
• Is every object name used in the pseudocode clearly understood by the target audience?
• If you find that a section of pseudocode needs elaboration or it doesn't explicitly outline a step that someone else might forget, go back and add the necessary information.

Community Q&A

• Pseudocode is optimal for complex programs that are hundreds to thousands of lines in length. Thanks Helpful 3 Not Helpful 0

• Pseudocode cannot be substituted for actual code when creating a program. Pseudocode can only be used to create a reference for what the code should do. Thanks Helpful 2 Not Helpful 0

You Might Also Like

• ↑ https://www.techopedia.com/definition/3946/pseudocode
• ↑ https://www.youtube.com/watch?v=D0qfR606tVo
• ↑ https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.3.0/com.ibm.zos.v2r3.ikjc300/ifthen.htm
• ↑ https://users.csc.calpoly.edu/~jdalbey/SWE/pdl_std.html

About This Article

1. Write the purpose of the process. 2. Write the initial steps that set the stage for functions. 3. Write only one statement per line. 4. Capitalize the initial keyword of each main direction. 5. Write what you mean, not how to program it. 6. Use standard programming structures. 7. Use blocks to structure steps. 8. Add comments if necessary. Did this summary help you? Yes No

• Send fan mail to authors

Is this article up to date?

Featured Articles

Trending Articles

Watch Articles

• Terms of Use
• Privacy Policy
• Do Not Sell or Share My Info
• Not Selling Info

Keep up with the latest tech with wikiHow's free Tech Help Newsletter