problem solving high level language

IN4110 – Problem Solving with High-Level Languages

Course description, course content, learning outcome, admission to the course, overlapping courses, examination, schedule, syllabus and examination date.

Autumn 2023

• Autumn 2022
• Autumn 2021
• Autumn 2020
• Autumn 2019

IN3110/IN4110 will not be held Autumn 2024.

This course provides an introduction to more advanced aspects of the scripting and programming language Python, e.g. object-oriented programming, regular expressions, interaction with the operating system, platform-independent code, efficient design of program systems with time-critical operations, extensions in compiled languages such as C/C++, data analysis and web programming. The course also provides a basic introduction to the scripting language Bash, testing and documentation of code, and version control system git. Special emphasis is placed on practical problem solving with a focus on interesting and study-relevant tasks.

After taking this course you'll:

• have knowledge of more advanced aspects of the Python programming language, including the use of regular expressions and interaction with the operating system
• be able to write scripts in Python and Bash to automate your own work tasks
• have knowledge of the version control system git and how code can be documented and tested
• be able to use vectorization to write efficient programs in Python
• be able to combine Python with compiled programming languages such as C and C++
• be able to write a web user interface for Python programs
• be able to use Python tools for advanced data analysis and machine learning
• be able to write programs that solve problems from different disciplines, such as physics, medicine, biology and finance
• have gained a deeper understanding of more advanced aspects of the Python language, such as efficient numerical calculations by extending Python with code written in C/C++ (extending Python)
• have learned to run data analytics and machine learning with advanced Python packages (Pandas and scikit-learn).

Students admitted at UiO must  apply for courses  in Studentweb. Students enrolled in other Master's Degree Programmes can, on application, be admitted to the course if this is cleared by their own study programme.

Nordic citizens and applicants residing in the Nordic countries may  apply to take this course as a single course student .

Recommended previous knowledge

• IN1000 – Introduction to Object-oriented Programming  or  IN1900 – Introduction to Programming with Scientific Applications
• IN1010 – Object-oriented Programming  or  IN1910 – Programming with Scientific Applications
• 10 credits overlap with IN3110 – Problem Solving with High-Level Languages .
• 10 credits overlap with INF3331 – Problemløsning med høynivå-språk (continued) .
• 10 credits overlap with INF4331 – Problem solving with high level languages (continued) .
• 5 credits overlap with INF3330 – Problem solving with high level languages (discontinued) .
• 5 credits overlap with INF4330 – Problem solving with high level languages (discontinued) .
• 5 credits overlap with INF5660 – Advanced problem solving with high level languages (discontinued) .

2 hours of lectures and 2 hours of exercises each week. Lectures will be a combination of ordinary lectures and supervised project work and problem solving.

Portfolio assessment.  Read more about requirements for submission of assignments, group work and legal cooperation under guidelines for mandatory assignments .

It will also be counted as one of your three attempts to sit the exam for this course, if you sit the exam for one of the following courses:  IN3110 – Problem Solving with High-Level Languages , INF3331 – Problemløsning med høynivå-språk (continued) , INF4331 – Problem solving with high level languages (continued)

Examination support material

Language of examination.

You may write your examination paper in Norwegian, Swedish, Danish or English.

Grading scale

Grades are awarded on a pass/fail scale. Read more about  the grading system .

More about examinations at UiO

• Use of sources and citations
• Special exam arrangements due to individual needs
• Withdrawal from an exam
• Illness at exams / postponed exams
• Explanation of grades and appeals
• Resitting an exam
• Cheating/attempted cheating

You will find further guides and resources at the web page on examinations at UiO .

Facts about this course

Department of Informatics

High level languages – advantages and disadvantages

High level language is abbreviated as HLL . High level languages are similar to the human language. Unlike low level languages, high level languages are programmers friendly, easy to code, debug and maintain.

High level language provides higher level of abstraction from machine language. They do not interact directly with the hardware. Rather, they focus more on the complex arithmetic operations, optimal program efficiency and easiness in coding.

Low level programming uses machine friendly language. Programmers writes code either in binary or assembly language. Writing programs in binary is complex and cumbersome process. Hence, to make programming more programmers friendly. Programs in high level language is written using English statements.

High level programs require compilers/interpreters to translate source code to machine language. We can compile the source code written in high level language to multiple machine languages. Thus, they are machine independent language.

Today almost all programs are developed using a high level programming language. We can develop a variety of applications using high level language. They are used to develop desktop applications, websites, system software’s, utility software’s and many more.

High level languages are grouped in two categories based on execution model – compiled or interpreted languages.

We can also classify high level language several other categories based on programming paradigm .

Advantages of High level language

• High level languages are programmer friendly. They are easy to write, debug and maintain.
• It provide higher level of abstraction from machine languages.
• It is machine independent language.
• Easy to learn.
• Less error prone, easy to find and debug errors.
• High level programming results in better programming productivity.

Disadvantages of High level language

• It takes additional translation times to translate the source to machine code.
• High level programs are comparatively slower than low level programs.
• Compared to low level programs, they are generally less memory efficient.
• Cannot communicate directly with the hardware.

• 1. Micro-Worlds
• 2. Light-Bot in Java
• 3. Jeroos of Santong Island
• 4. Problem Solving and Algorithms
• 5. Creating Jeroo Methods
• 6. Conditionally Executing Actions
• 7. Repeating Actions
• 8. Handling Touch Events
• 9. Adding Text to the Screen

Problem Solving and Algorithms

Learn a basic process for developing a solution to a problem. Nothing in this chapter is unique to using a computer to solve a problem. This process can be used to solve a wide variety of problems, including ones that have nothing to do with computers.

Problems, Solutions, and Tools

I have a problem! I need to thank Aunt Kay for the birthday present she sent me. I could send a thank you note through the mail. I could call her on the telephone. I could send her an email message. I could drive to her house and thank her in person. In fact, there are many ways I could thank her, but that's not the point. The point is that I must decide how I want to solve the problem, and use the appropriate tool to implement (carry out) my plan. The postal service, the telephone, the internet, and my automobile are tools that I can use, but none of these actually solves my problem. In a similar way, a computer does not solve problems, it's just a tool that I can use to implement my plan for solving the problem.

Knowing that Aunt Kay appreciates creative and unusual things, I have decided to hire a singing messenger to deliver my thanks. In this context, the messenger is a tool, but one that needs instructions from me. I have to tell the messenger where Aunt Kay lives, what time I would like the message to be delivered, and what lyrics I want sung. A computer program is similar to my instructions to the messenger.

The story of Aunt Kay uses a familiar context to set the stage for a useful point of view concerning computers and computer programs. The following list summarizes the key aspects of this point of view.

A computer is a tool that can be used to implement a plan for solving a problem.

A computer program is a set of instructions for a computer. These instructions describe the steps that the computer must follow to implement a plan.

An algorithm is a plan for solving a problem.

A person must design an algorithm.

A person must translate an algorithm into a computer program.

This point of view sets the stage for a process that we will use to develop solutions to Jeroo problems. The basic process is important because it can be used to solve a wide variety of problems, including ones where the solution will be written in some other programming language.

An Algorithm Development Process

Every problem solution starts with a plan. That plan is called an algorithm.

There are many ways to write an algorithm. Some are very informal, some are quite formal and mathematical in nature, and some are quite graphical. The instructions for connecting a DVD player to a television are an algorithm. A mathematical formula such as πR 2 is a special case of an algorithm. The form is not particularly important as long as it provides a good way to describe and check the logic of the plan.

The development of an algorithm (a plan) is a key step in solving a problem. Once we have an algorithm, we can translate it into a computer program in some programming language. Our algorithm development process consists of five major steps.

Step 1: Obtain a description of the problem.

Step 2: analyze the problem., step 3: develop a high-level algorithm., step 4: refine the algorithm by adding more detail., step 5: review the algorithm..

This step is much more difficult than it appears. In the following discussion, the word client refers to someone who wants to find a solution to a problem, and the word developer refers to someone who finds a way to solve the problem. The developer must create an algorithm that will solve the client's problem.

The client is responsible for creating a description of the problem, but this is often the weakest part of the process. It's quite common for a problem description to suffer from one or more of the following types of defects: (1) the description relies on unstated assumptions, (2) the description is ambiguous, (3) the description is incomplete, or (4) the description has internal contradictions. These defects are seldom due to carelessness by the client. Instead, they are due to the fact that natural languages (English, French, Korean, etc.) are rather imprecise. Part of the developer's responsibility is to identify defects in the description of a problem, and to work with the client to remedy those defects.

The purpose of this step is to determine both the starting and ending points for solving the problem. This process is analogous to a mathematician determining what is given and what must be proven. A good problem description makes it easier to perform this step.

When determining the starting point, we should start by seeking answers to the following questions:

What data are available?

Where is that data?

What formulas pertain to the problem?

What rules exist for working with the data?

What relationships exist among the data values?

When determining the ending point, we need to describe the characteristics of a solution. In other words, how will we know when we're done? Asking the following questions often helps to determine the ending point.

What new facts will we have?

What items will have changed?

What changes will have been made to those items?

What things will no longer exist?

An algorithm is a plan for solving a problem, but plans come in several levels of detail. It's usually better to start with a high-level algorithm that includes the major part of a solution, but leaves the details until later. We can use an everyday example to demonstrate a high-level algorithm.

Problem: I need a send a birthday card to my brother, Mark.

Analysis: I don't have a card. I prefer to buy a card rather than make one myself.

High-level algorithm:

Go to a store that sells greeting cards Select a card Purchase a card Mail the card

This algorithm is satisfactory for daily use, but it lacks details that would have to be added were a computer to carry out the solution. These details include answers to questions such as the following.

"Which store will I visit?"

"How will I get there: walk, drive, ride my bicycle, take the bus?"

"What kind of card does Mark like: humorous, sentimental, risqué?"

These kinds of details are considered in the next step of our process.

A high-level algorithm shows the major steps that need to be followed to solve a problem. Now we need to add details to these steps, but how much detail should we add? Unfortunately, the answer to this question depends on the situation. We have to consider who (or what) is going to implement the algorithm and how much that person (or thing) already knows how to do. If someone is going to purchase Mark's birthday card on my behalf, my instructions have to be adapted to whether or not that person is familiar with the stores in the community and how well the purchaser known my brother's taste in greeting cards.

When our goal is to develop algorithms that will lead to computer programs, we need to consider the capabilities of the computer and provide enough detail so that someone else could use our algorithm to write a computer program that follows the steps in our algorithm. As with the birthday card problem, we need to adjust the level of detail to match the ability of the programmer. When in doubt, or when you are learning, it is better to have too much detail than to have too little.

Most of our examples will move from a high-level to a detailed algorithm in a single step, but this is not always reasonable. For larger, more complex problems, it is common to go through this process several times, developing intermediate level algorithms as we go. Each time, we add more detail to the previous algorithm, stopping when we see no benefit to further refinement. This technique of gradually working from a high-level to a detailed algorithm is often called stepwise refinement .

The final step is to review the algorithm. What are we looking for? First, we need to work through the algorithm step by step to determine whether or not it will solve the original problem. Once we are satisfied that the algorithm does provide a solution to the problem, we start to look for other things. The following questions are typical of ones that should be asked whenever we review an algorithm. Asking these questions and seeking their answers is a good way to develop skills that can be applied to the next problem.

Does this algorithm solve a very specific problem or does it solve a more general problem ? If it solves a very specific problem, should it be generalized?

For example, an algorithm that computes the area of a circle having radius 5.2 meters (formula π*5.2 2 ) solves a very specific problem, but an algorithm that computes the area of any circle (formula π*R 2 ) solves a more general problem.

Can this algorithm be simplified ?

One formula for computing the perimeter of a rectangle is:

length + width + length + width

A simpler formula would be:

2.0 * ( length + width )

Is this solution similar to the solution to another problem? How are they alike? How are they different?

For example, consider the following two formulae:

Rectangle area = length * width Triangle area = 0.5 * base * height

Similarities: Each computes an area. Each multiplies two measurements.

Differences: Different measurements are used. The triangle formula contains 0.5.

Hypothesis: Perhaps every area formula involves multiplying two measurements.

Example 4.1: Pick and Plant

This section contains an extended example that demonstrates the algorithm development process. To complete the algorithm, we need to know that every Jeroo can hop forward, turn left and right, pick a flower from its current location, and plant a flower at its current location.

Problem Statement (Step 1)

A Jeroo starts at (0, 0) facing East with no flowers in its pouch. There is a flower at location (3, 0). Write a program that directs the Jeroo to pick the flower and plant it at location (3, 2). After planting the flower, the Jeroo should hop one space East and stop. There are no other nets, flowers, or Jeroos on the island.

Analysis of the Problem (Step 2)

The flower is exactly three spaces ahead of the jeroo.

The flower is to be planted exactly two spaces South of its current location.

The Jeroo is to finish facing East one space East of the planted flower.

There are no nets to worry about.

High-level Algorithm (Step 3)

Let's name the Jeroo Bobby. Bobby should do the following:

Get the flower Put the flower Hop East

Detailed Algorithm (Step 4)

Get the flower Hop 3 times Pick the flower Put the flower Turn right Hop 2 times Plant a flower Hop East Turn left Hop once

Review the Algorithm (Step 5)

The high-level algorithm partitioned the problem into three rather easy subproblems. This seems like a good technique.

This algorithm solves a very specific problem because the Jeroo and the flower are in very specific locations.

This algorithm is actually a solution to a slightly more general problem in which the Jeroo starts anywhere, and the flower is 3 spaces directly ahead of the Jeroo.

Java Code for "Pick and Plant"

A good programmer doesn't write a program all at once. Instead, the programmer will write and test the program in a series of builds. Each build adds to the previous one. The high-level algorithm will guide us in this process.

FIRST BUILD

To see this solution in action, create a new Greenfoot4Sofia scenario and use the Edit Palettes Jeroo menu command to make the Jeroo classes visible. Right-click on the Island class and create a new subclass with the name of your choice. This subclass will hold your new code.

The recommended first build contains three things:

The main method (here myProgram() in your island subclass).

Declaration and instantiation of every Jeroo that will be used.

The high-level algorithm in the form of comments.

The instantiation at the beginning of myProgram() places bobby at (0, 0), facing East, with no flowers.

Once the first build is working correctly, we can proceed to the others. In this case, each build will correspond to one step in the high-level algorithm. It may seem like a lot of work to use four builds for such a simple program, but doing so helps establish habits that will become invaluable as the programs become more complex.

SECOND BUILD

This build adds the logic to "get the flower", which in the detailed algorithm (step 4 above) consists of hopping 3 times and then picking the flower. The new code is indicated by comments that wouldn't appear in the original (they are just here to call attention to the additions). The blank lines help show the organization of the logic.

By taking a moment to run the work so far, you can confirm whether or not this step in the planned algorithm works as expected.

THIRD BUILD

This build adds the logic to "put the flower". New code is indicated by the comments that are provided here to mark the additions.

FOURTH BUILD (final)

Example 4.2: replace net with flower.

This section contains a second example that demonstrates the algorithm development process.

There are two Jeroos. One Jeroo starts at (0, 0) facing North with one flower in its pouch. The second starts at (0, 2) facing East with one flower in its pouch. There is a net at location (3, 2). Write a program that directs the first Jeroo to give its flower to the second one. After receiving the flower, the second Jeroo must disable the net, and plant a flower in its place. After planting the flower, the Jeroo must turn and face South. There are no other nets, flowers, or Jeroos on the island.

Jeroo_2 is exactly two spaces behind Jeroo_1.

The only net is exactly three spaces ahead of Jeroo_2.

Each Jeroo has exactly one flower.

Jeroo_2 will have two flowers after receiving one from Jeroo_1. One flower must be used to disable the net. The other flower must be planted at the location of the net, i.e. (3, 2).

Jeroo_1 will finish at (0, 1) facing South.

Jeroo_2 is to finish at (3, 2) facing South.

Each Jeroo will finish with 0 flowers in its pouch. One flower was used to disable the net, and the other was planted.

Let's name the first Jeroo Ann and the second one Andy.

Ann should do the following: Find Andy (but don't collide with him) Give a flower to Andy (he will be straight ahead) After receiving the flower, Andy should do the following: Find the net (but don't hop onto it) Disable the net Plant a flower at the location of the net Face South

Ann should do the following: Find Andy Turn around (either left or right twice) Hop (to location (0, 1)) Give a flower to Andy Give ahead Now Andy should do the following: Find the net Hop twice (to location (2, 2)) Disable the net Toss Plant a flower at the location of the net Hop (to location (3, 2)) Plant a flower Face South Turn right

The high-level algorithm helps manage the details.

This algorithm solves a very specific problem, but the specific locations are not important. The only thing that is important is the starting location of the Jeroos relative to one another and the location of the net relative to the second Jeroo's location and direction.

Java Code for "Replace Net with Flower"

As before, the code should be written incrementally as a series of builds. Four builds will be suitable for this problem. As usual, the first build will contain the main method, the declaration and instantiation of the Jeroo objects, and the high-level algorithm in the form of comments. The second build will have Ann give her flower to Andy. The third build will have Andy locate and disable the net. In the final build, Andy will place the flower and turn East.

This build creates the main method, instantiates the Jeroos, and outlines the high-level algorithm. In this example, the main method would be myProgram() contained within a subclass of Island .

This build adds the logic for Ann to locate Andy and give him a flower.

This build adds the logic for Andy to locate and disable the net.

This build adds the logic for Andy to place a flower at (3, 2) and turn South.

Learn by   .css-1v0lc0l{color:var(--chakra-colors-blue-500);} doing

Guided interactive problem solving that’s effective and fun. Master concepts in 15 minutes a day.

Data Analysis

Computer Science

Programming & AI

Science & Engineering

Join over 10 million people learning on Brilliant

Master concepts in 15 minutes a day.

Whether you’re a complete beginner or ready to dive into machine learning and beyond, Brilliant makes it easy to level up fast with fun, bite-sized lessons.

Effective, hands-on learning

Visual, interactive lessons make concepts feel intuitive — so even complex ideas just click. Our real-time feedback and simple explanations make learning efficient.

Learn at your level

Students and professionals alike can hone dormant skills or learn new ones. Progress through lessons and challenges tailored to your level. Designed for ages 13 to 113.

Guided bite-sized lessons

We make it easy to stay on track, see your progress, and build your problem-solving skills one concept at a time.

Stay motivated

Form a real learning habit with fun content that’s always well-paced, game-like progress tracking, and friendly reminders.

© 2024 Brilliant Worldwide, Inc., Brilliant and the Brilliant Logo are trademarks of Brilliant Worldwide, Inc.

How to think like a programmer — lessons in problem solving

By Richard Reis

If you’re interested in programming, you may well have seen this quote before:

“Everyone in this country should learn to program a computer, because it teaches you to think.” — Steve Jobs

You probably also wondered what does it mean, exactly, to think like a programmer? And how do you do it??

Essentially, it’s all about a more effective way for problem solving .

In this post, my goal is to teach you that way.

By the end of it, you’ll know exactly what steps to take to be a better problem-solver.

Why is this important?

Problem solving is the meta-skill.

We all have problems. Big and small. How we deal with them is sometimes, well…pretty random.

Unless you have a system, this is probably how you “solve” problems (which is what I did when I started coding):

• Try a solution.
• If that doesn’t work, try another one.
• If that doesn’t work, repeat step 2 until you luck out.

Look, sometimes you luck out. But that is the worst way to solve problems! And it’s a huge, huge waste of time.

The best way involves a) having a framework and b) practicing it.

“Almost all employers prioritize problem-solving skills first. Problem-solving skills are almost unanimously the most important qualification that employers look for….more than programming languages proficiency, debugging, and system design. Demonstrating computational thinking or the ability to break down large, complex problems is just as valuable (if not more so) than the baseline technical skills required for a job.” — Hacker Rank ( 2018 Developer Skills Report )

Have a framework

To find the right framework, I followed the advice in Tim Ferriss’ book on learning, “ The 4-Hour Chef ”.

It led me to interview two really impressive people: C. Jordan Ball (ranked 1st or 2nd out of 65,000+ users on Coderbyte ), and V. Anton Spraul (author of the book “ Think Like a Programmer: An Introduction to Creative Problem Solving ”).

I asked them the same questions, and guess what? Their answers were pretty similar!

Soon, you too will know them.

Sidenote: this doesn’t mean they did everything the same way. Everyone is different. You’ll be different. But if you start with principles we all agree are good, you’ll get a lot further a lot quicker.

“The biggest mistake I see new programmers make is focusing on learning syntax instead of learning how to solve problems.” — V. Anton Spraul

So, what should you do when you encounter a new problem?

Here are the steps:

1. Understand

Know exactly what is being asked. Most hard problems are hard because you don’t understand them (hence why this is the first step).

How to know when you understand a problem? When you can explain it in plain English.

Do you remember being stuck on a problem, you start explaining it, and you instantly see holes in the logic you didn’t see before?

Most programmers know this feeling.

This is why you should write down your problem, doodle a diagram, or tell someone else about it (or thing… some people use a rubber duck ).

“If you can’t explain something in simple terms, you don’t understand it.” — Richard Feynman

Don’t dive right into solving without a plan (and somehow hope you can muddle your way through). Plan your solution!

Nothing can help you if you can’t write down the exact steps.

In programming, this means don’t start hacking straight away. Give your brain time to analyze the problem and process the information.

To get a good plan, answer this question:

“Given input X, what are the steps necessary to return output Y?”

Sidenote: Programmers have a great tool to help them with this… Comments!

Pay attention. This is the most important step of all.

Do not try to solve one big problem. You will cry.

Instead, break it into sub-problems. These sub-problems are much easier to solve.

Then, solve each sub-problem one by one. Begin with the simplest. Simplest means you know the answer (or are closer to that answer).

After that, simplest means this sub-problem being solved doesn’t depend on others being solved.

Once you solved every sub-problem, connect the dots.

Connecting all your “sub-solutions” will give you the solution to the original problem. Congratulations!

This technique is a cornerstone of problem-solving. Remember it (read this step again, if you must).

“If I could teach every beginning programmer one problem-solving skill, it would be the ‘reduce the problem technique.’ For example, suppose you’re a new programmer and you’re asked to write a program that reads ten numbers and figures out which number is the third highest. For a brand-new programmer, that can be a tough assignment, even though it only requires basic programming syntax. If you’re stuck, you should reduce the problem to something simpler. Instead of the third-highest number, what about finding the highest overall? Still too tough? What about finding the largest of just three numbers? Or the larger of two? Reduce the problem to the point where you know how to solve it and write the solution. Then expand the problem slightly and rewrite the solution to match, and keep going until you are back where you started.” — V. Anton Spraul

By now, you’re probably sitting there thinking “Hey Richard... That’s cool and all, but what if I’m stuck and can’t even solve a sub-problem??”

First off, take a deep breath. Second, that’s fair.

Don’t worry though, friend. This happens to everyone!

The difference is the best programmers/problem-solvers are more curious about bugs/errors than irritated.

In fact, here are three things to try when facing a whammy:

• Debug: Go step by step through your solution trying to find where you went wrong. Programmers call this debugging (in fact, this is all a debugger does).

“The art of debugging is figuring out what you really told your program to do rather than what you thought you told it to do.”” — Andrew Singer

• Reassess: Take a step back. Look at the problem from another perspective. Is there anything that can be abstracted to a more general approach?

“Sometimes we get so lost in the details of a problem that we overlook general principles that would solve the problem at a more general level. […] The classic example of this, of course, is the summation of a long list of consecutive integers, 1 + 2 + 3 + … + n, which a very young Gauss quickly recognized was simply n(n+1)/2, thus avoiding the effort of having to do the addition.” — C. Jordan Ball

Sidenote: Another way of reassessing is starting anew. Delete everything and begin again with fresh eyes. I’m serious. You’ll be dumbfounded at how effective this is.

• Research: Ahh, good ol’ Google. You read that right. No matter what problem you have, someone has probably solved it. Find that person/ solution. In fact, do this even if you solved the problem! (You can learn a lot from other people’s solutions).

Caveat: Don’t look for a solution to the big problem. Only look for solutions to sub-problems. Why? Because unless you struggle (even a little bit), you won’t learn anything. If you don’t learn anything, you wasted your time.

Don’t expect to be great after just one week. If you want to be a good problem-solver, solve a lot of problems!

Practice. Practice. Practice. It’ll only be a matter of time before you recognize that “this problem could easily be solved with .”

How to practice? There are options out the wazoo!

Chess puzzles, math problems, Sudoku, Go, Monopoly, video-games, cryptokitties, bla… bla… bla….

In fact, a common pattern amongst successful people is their habit of practicing “micro problem-solving.” For example, Peter Thiel plays chess, and Elon Musk plays video-games.

“Byron Reeves said ‘If you want to see what business leadership may look like in three to five years, look at what’s happening in online games.’ Fast-forward to today. Elon [Musk], Reid [Hoffman], Mark Zuckerberg and many others say that games have been foundational to their success in building their companies.” — Mary Meeker ( 2017 internet trends report )

Does this mean you should just play video-games? Not at all.

But what are video-games all about? That’s right, problem-solving!

So, what you should do is find an outlet to practice. Something that allows you to solve many micro-problems (ideally, something you enjoy).

For example, I enjoy coding challenges. Every day, I try to solve at least one challenge (usually on Coderbyte ).

Like I said, all problems share similar patterns.

That’s all folks!

Now, you know better what it means to “think like a programmer.”

You also know that problem-solving is an incredible skill to cultivate (the meta-skill).

As if that wasn’t enough, notice how you also know what to do to practice your problem-solving skills!

Phew… Pretty cool right?

Finally, I wish you encounter many problems.

You read that right. At least now you know how to solve them! (also, you’ll learn that with every solution, you improve).

“Just when you think you’ve successfully navigated one obstacle, another emerges. But that’s what keeps life interesting.[…] Life is a process of breaking through these impediments — a series of fortified lines that we must break through. Each time, you’ll learn something. Each time, you’ll develop strength, wisdom, and perspective. Each time, a little more of the competition falls away. Until all that is left is you: the best version of you.” — Ryan Holiday ( The Obstacle is the Way )

Now, go solve some problems!

And best of luck ?

Special thanks to C. Jordan Ball and V. Anton Spraul . All the good advice here came from them.

Thanks for reading! If you enjoyed it, test how many times can you hit in 5 seconds. It’s great cardio for your fingers AND will help other people see the story.

freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Ada Computer Science

You need to enable JavaScript to access Ada Computer Science.

Solving Problems with a High-Level Programming Language

Cite this chapter.

• David R. Brooks 3  

Part of the book series: Undergraduate Texts in Computer Science ((UTCS))

1090 Accesses

This chapter presents a general approach to using computers to solve certain kinds of computational problems. It describes instructions and data types common to structured programming with high-level procedural languages and defines a specific strategy for developing algorithms that can easily be translated into a language such as Fortran. It includes a short Fortran program that you can copy and execute on the computer you will be using for a course based on this text.

This is a preview of subscription content, log in via an institution to check access.

Access this chapter

Subscribe and save.

• Get 10 units per month
• Download Article/Chapter or eBook
• 1 Unit = 1 Article or 1 Chapter
• Cancel anytime
• Available as PDF
• Read on any device
• Instant download
• Own it forever
• Compact, lightweight edition
• Dispatched in 3 to 5 business days
• Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Unable to display preview.  Download preview PDF.

Author information

Authors and affiliations.

Department of Mathematics and Computer Science, Drexel University, Philadelphia, PA, 19104, USA

David R. Brooks

You can also search for this author in PubMed   Google Scholar

Rights and permissions

Reprints and permissions

Copyright information

© 1997 Springer Science+Business Media New York

About this chapter

Brooks, D.R. (1997). Solving Problems with a High-Level Programming Language. In: Problem Solving with Fortran 90. Undergraduate Texts in Computer Science. Springer, New York, NY. https://doi.org/10.1007/978-1-4612-1952-1_2

Download citation

DOI : https://doi.org/10.1007/978-1-4612-1952-1_2

Publisher Name : Springer, New York, NY

Print ISBN : 978-1-4612-7353-0

Online ISBN : 978-1-4612-1952-1

eBook Packages : Springer Book Archive

Share this chapter

Anyone you share the following link with will be able to read this content:

Sorry, a shareable link is not currently available for this article.

Provided by the Springer Nature SharedIt content-sharing initiative

• Publish with us

Policies and ethics

• Find a journal
• Track your research

High Level Languages: Types & 30 Examples of High Level Language

High-level languages are easy to understand, provide abstraction from machine code, and offer built-in functions, libraries, and tools for increased productivity. Now, in this blog post, we are going to explain about what is high level language and its types ; as well as involving with many examples of high level language with ease. At the end of this article, you have been fully educated about High Level Languages without getting any hassle.

What is High Level Language?

High-level languages are intended to be more user-friendly and productive than low-level languages, such as assembly or machine code. They provide a higher level of abstraction and encapsulate complex operations into simpler and more readable syntax. This makes programming more accessible to a wider range of people, including those without deep knowledge of computer hardware or low-level programming concepts.

Hence, high-level languages provide programmers with a more expressive and readable way to write code, enabling them to focus on solving problems and implementing algorithms rather than dealing with low-level details of the computer’s architecture.

‘High Level Language’ Tutorial Headlines:

Let’s get started, different types of high level language.

High-level programming languages can be categorized into different types based on their design philosophy, application domains, and paradigms. Here are some common types of high-level languages:

Also Read: 40 Advantages and Disadvantages of High Level Languages | Features & Characteristics

Procedural Languages: These languages focus on a sequence of instructions that manipulate data using procedures or subroutines. Examples include C, Pascal, and FORTRAN.

Functional Languages: Functional languages treat computation as the evaluation of mathematical functions and avoid changing state and mutable data. They emphasize immutability and higher-order functions. Examples include Haskell, Lisp, and Scala.

Scripting Languages: Scripting languages are designed for automating tasks and writing scripts to control software applications. They are often interpreted and have dynamic typing. Examples include Python, Perl, and Ruby.

Markup Languages: Markup languages are used to annotate and structure documents or data. They do not typically have full programming capabilities but provide a way to describe the structure and presentation of content. Examples include HTML (for web pages), XML (for data exchange), and LaTeX (for typesetting).

Concurrent Languages: Concurrent languages are designed to handle concurrent or parallel programming, allowing multiple tasks or processes to execute simultaneously. Examples include Go, Erlang, and Ada.

Data Analysis and Statistical Languages: These languages are designed specifically for data manipulation, analysis, and statistical modeling. Examples include R and MATLAB.

Visual Programming Languages: Visual programming languages use visual elements and graphical representations to create programs. They often target non-programmers or beginners and facilitate visual manipulation of program elements. Examples include Scratch and Blockly.

Constraint-Based Languages: Constraint-based languages enable expressing relationships and constraints among variables, allowing for declarative problem solving. They are often used in optimization, scheduling, and constraint satisfaction problems. Examples include MiniZinc and ECLiPSe.

Database Query Languages: These languages are used to retrieve and manipulate data stored in databases. They provide a structured way to query, update, and manage databases. Examples include SQL (Structured Query Language) and its variations like MySQL and PostgreSQL.

Scripting Automation Languages: These languages are designed for automating tasks and interacting with system utilities and applications. They often provide easy integration with operating system functions and external programs. Examples include PowerShell and Bash scripting.

Web Development Languages: Web development languages are specifically used for building web applications, including both client-side and server-side programming. Examples include HTML, CSS, JavaScript, PHP, and Ruby on Rails.

Scripting Languages for Software Applications: Some applications allow users to extend their functionality using scripting languages. These languages provide an interface to automate and customize the application’s behavior. Examples include Lua (used in game development) and AutoHotkey (used for desktop automation).

Machine Learning Languages: Machine learning languages focus on developing models and algorithms for data analysis, pattern recognition, and artificial intelligence applications. Examples include Python with libraries like TensorFlow and PyTorch.

Examples of High level Languages

There are numerous high-level programming languages available, each with its own features and areas of application. Here are some popular examples of high-level languages, as following them:

List of High Level Programming Language Examples

Python: Python is a popular high-level language known for its simplicity and readability. It emphasizes code readability and uses indentation to define code blocks.

C++: C++ is a powerful high-level language that supports both procedural and object-oriented programming. It is commonly used for system-level programming, game development, and performance-critical applications.

JavaScript: JavaScript is a high-level language primarily used for web development. It runs in web browsers and allows interactive elements and dynamic content on websites.

Ruby: Ruby is a high-level, dynamic language known for its elegant syntax. It focuses on simplicity and productivity, making it popular for web development using the Ruby on Rails framework.

Swift: Swift is a high-level language developed by Apple for iOS, macOS, watchOS, and tvOS development. It offers modern syntax, type safety, and performance optimizations.

MATLAB: MATLAB is a high-level language often used in scientific and engineering fields. It provides a comprehensive environment for numerical computation, data analysis, and visualization.

Go: Go, also known as Golang, is a high-level language developed by Google. It focuses on simplicity, efficiency, and concurrency and is often used for building scalable and efficient networked applications.

Perl: Perl is a high-level language known for its strong text-processing capabilities. It is often used for tasks such as parsing and manipulating large amounts of textual data.

Kotlin: Kotlin is a modern high-level language that runs on the Java Virtual Machine (JVM). It is an official language for Android app development and offers enhanced features and syntax compared to Java.

Scala: Scala is a high-level language that combines object-oriented and functional programming concepts. It runs on the JVM and is often used for building scalable and distributed systems.

Rust: Rust is a high-level language focused on safety, concurrency, and low-level system programming. It aims to prevent common programming errors and provides memory safety guarantees without sacrificing performance.

Groovy: Groovy is a high-level language that runs on the Java Virtual Machine (JVM) and shares syntax and features with Java. It emphasizes simplicity and productivity and is often used for scripting and rapid application development.

Lua: Lua is a lightweight high-level language known for its simplicity and embeddability. It is often used as a scripting language in game development and embedded systems .

Haskell: Haskell is a purely functional high-level language known for its strong type system and advanced type inference. It is often used in academia and for projects involving mathematical or logic-based computations.

Prolog: Prolog is a high-level language based on logic programming. It is used for tasks such as artificial intelligence, expert systems, and natural language processing.

Dart: Dart is a high-level language developed by Google and primarily used with the Flutter framework for building cross-platform mobile, web, and desktop applications.

PowerShell: PowerShell is a high-level language developed by Microsoft for task automation and configuration management. It provides extensive access to system APIs and is commonly used for scripting in the Windows environment.

Scratch: Scratch is a visual programming language designed for beginners, particularly children. It uses a drag-and-drop interface to create interactive stories, games, and animations.

Haxe: Haxe is a high-level language that can be transpiled to several target languages, including JavaScript, C++, and Java. It is often used for cross-platform development, game development, and multimedia applications. Haxe provides a single codebase that can be compiled to multiple platforms.

Crystal: Crystal is a statically typed, compiled language with a syntax inspired by Ruby. It aims to provide the performance of a compiled language while maintaining developer productivity. Crystal is often used for web development, system programming, and building command-line tools.

Ada: Ada is a high-level language developed for embedded systems and safety-critical applications. It emphasizes reliability, maintainability, and correctness. Ada is used in domains such as aerospace, defense, and transportation, where safety and robustness are essential.

FAQs (Frequently Asked Questions)

What is high level language and its types.

A high-level language is a programming language that is designed to be easily understood and written by humans. There are several types of high-level programming languages, including: Procedural Languages, Object-Oriented Languages, Functional Languages, Scripting Languages, Markup Languages, Domain-Specific Languages, and etc.

Why high-level language is called high?

The term “high-level language” is used to describe programming languages that are designed to be closer to human language and are more abstract and easier to understand compared to low-level languages. The “high” in “high-level” refers to the level of abstraction provided by these languages.

Which is first high-level language?

What are some examples of high-level languages and their meaning.

Above in this article, already we have been many examples of high level programming languages with their meaning, you can check them.

How are high-level languages different from low-level languages?

High-level languages are designed to be more human-readable and provide abstractions from the underlying hardware, while low-level languages are closer to the machine code and provide direct control over the hardware. High-level languages are easier to learn and use, but they sacrifice some performance and control compared to low-level languages.

Can high-level languages be used for system programming?

Is it possible to switch from one high-level language to another.

Yes, it is generally possible to switch from one high-level language to another, although it may require some effort to learn the syntax, libraries, and paradigms of the new language. Many high-level languages share common programming concepts, so transitioning between them can be relatively straightforward for experienced programmers.

Can high-level languages interact with low-level languages?

Yes, high-level languages can interact with low-level languages. Most high-level languages provide mechanisms, such as foreign function interfaces or libraries, to interface with low-level languages like C or C++. This allows developers to leverage the performance benefits of low-level code when necessary or when interfacing with system-level operations.

Final Words

If you have any experience, tips, tricks, or query regarding this issue? You can drop a comment!

Related Posts

Leave a reply cancel reply.

What Are High Level Programming Languages: Types and Uses

High level programming languages are the backbone of modern software development, offering a bridge between human logic and machine execution. These computer programming languages simplify coding tasks for developers of all levels. With their versatility, readability, and extensive ecosystems, high-level programming languages continue to drive the evolution of technology and shape the digital landscape.

At Aloa, a software outsourcing firm , we specialize in delivering tailored solutions to meet our client’s diverse needs. Our rigorous vetting process ensures we only collaborate with experts proficient in high-level and low-level language. This expertise positions us as industry leaders in facilitating successful partnerships between businesses and skilled developers.

Drawing from our extensive expertise, we’ve compiled this guide to provide insights into different types and uses of high level programming languages. Our experience spans popular programming languages like Python , JavaScript, and Ruby, enabling us to understand their strengths and weaknesses. From that experience, you’ll have a deep understanding of various programming languages that can make your coding journey easier.

Let’s delve in!

What are High Level Programming Languages? 

High level programming languages refer to coding languages that are designed to be more intuitive and user-friendly for human programmers. They abstract away low-level details of computer hardware to make coding more accessible. These languages typically have simpler syntax and require fewer lines of code than low-level languages. 

Additionally, higher-level languages provide a significant level of abstraction from machine language, enabling developers to focus on solving complex problems. With their extensive documentation and community support, these languages aid programmers in streamlining their software and application development. 

Examples of High Level Languages

High level programming languages are widely used in various fields of computer science and software development. They offer developers the flexibility and convenience to build various applications. Some of the most popular programming languages include:

• Python: Renowned for its simplicity, versatility, and strong emphasis on code readability, Python is widely favored in various fields such as web development, data analysis, and artificial intelligence. Its clean syntax and extensive libraries contribute to its ease of use, making it a top choice for developers across different domains, including those who utilize Replit Python .
• Java: Java is frequently utilized in enterprise-level applications, Android app development, big data tools, large-scale systems, and functional programming languages. Its robust ecosystem and extensive community support make Java a dependable choice for Java developers.
• JavaScript: Primarily used for web development, JavaScript powers dynamic and interactive website features, making it essential for front-end and back-end development. Its flexibility and compatibility with frameworks like React and Node.js have made it a cornerstone of modern web development.
• C#: Developed by Microsoft, C# is favored for building Windows applications, web services, games using Unity, and enterprise software solutions. Its robust typing system and easy integration with the .NET framework make it popular for building robust and scalable applications.
• C++: Renowned for its performance and flexibility, C++ is a go-to for game development, system programming, and performance-critical applications among C++ developers . Its ability to directly manipulate hardware and manage memory makes it a powerful tool for building high-performance applications.
• Ruby: Prized for its simplicity and productivity, Ruby is often chosen for web development, particularly with the Ruby on Rails framework. Its elegant syntax and focus on developer satisfaction have made it a favorite among startups and established companies.
• Swift: Swift offers modern syntax and performance enhancements for building Apple ecosystem apps. Its safety features and interoperability with Objective C make it a preferred choice for developing native iOS and macOS applications.

Understanding these high level programming languages provides a glimpse into the wide range of tools that are available to developers. 

How To Choose the Best High Level Programming Languages for your Project

With various options available, selecting the best high level programming language for your project can be daunting. However, by following a systematic approach, you can make an informed decision that aligns with your project’s requirements and goals. Here, we outline the steps to navigate this process effectively and choose the optimal language for your project’s success.

Step 1: Define Project Requirements

Defining project requirements is the crucial first step in selecting the best high level programming language for your project. Start by outlining your project’s objectives, scope, and expected outcomes to establish clear goals. Afterward, identify any specific functionalities, performance criteria, or compatibility requirements for achieving project success. 

You may also consider factors such as target platform, scalability, and integration with existing systems to ensure compatibility with your project’s environment. Be sure that stakeholders, developers, and other individuals are involved in gathering the requirement process to cater diverse perspectives and ensure comprehensive coverage of project needs.

Step 2: Assess Language Compatibility

Assessing language compatibility entails scrutinizing how effectively a programming language aligns with the technical requirements of your project, considering both control and data structures. This evaluation is pivotal to circumvent potential limitations or mismatches between the language's capabilities and project needs. Failing to figure this out could impede development progress or lead to suboptimal outcomes.

Here are the considerations to take in assessing language compatibility:

• Platform Support: Determine whether the language supports the platforms and operating systems relevant to your project to ensure seamless deployment and compatibility.
• Performance Requirements: Evaluate the language’s performance characteristics, including execution speed, memory usage, and scalability, to ensure it can meet the project’s performance demands efficiently.
• Library and Framework Availability: Consider the availability of libraries, frameworks, and third-party tools associated with the high level programming language, as they can significantly impact development productivity.
• Integration with Existing Systems: Determine whether the language can integrate seamlessly with any existing systems, databases, or technologies already used within your project environment.

Step 3: Consider Developer Expertise 

Consideration of developer expertise is paramount when choosing among the best high level programming languages for your project. To do that, assess the proficiency and familiarity of your development team with different languages to ensure they can effectively utilize each language’s features and capabilities. 

Once done, match the language to your team’s expertise so you can enhance productivity and reduce learning curves. Doing this ensures you can have faster development cycles and improved code quality. Additionally, leveraging your team’s existing skills and knowledge can foster collaboration and teamwork, as developers can share insights and best practices within a familiar framework. 

Step 4: Evaluate Ecosystem Support

Evaluating ecosystem support involves assessing the availability and quality of resources, libraries, and tools within the programming language’s ecosystem. This evaluation helps determine the level of community engagement, documentation, and development resources available to support developers in their projects. 

Here are a few considerations to take when evaluating ecosystem support

• Community Engagement: Assess the activity and engagement of the language’s community, including forums, discussion groups, and open-source contributions, as an active community fosters collaboration and support.
• Documentation Quality: Evaluate the quality and comprehensiveness of the language’s documentation and official resources, as well as document libraries and tutorials, which can significantly ease the learning curve for developers.
• Development Tools: Consider the availability of development tools, integrated development environments (IDEs), and package managers tailored to the language, which can enhance productivity and streamline the development process.
• Long-Term Support: Examine the language’s roadmap, release cycles, and ongoing development efforts to gauge its long-term viability and ensure continued support and updates for future projects.

Step 5: Analyze Performance Considerations

Analyzing performance considerations involves assessing how efficiently a high level programming language can execute tasks and utilize system resources. This evaluation typically involves measuring various factors to ensure the language can meet the performance requirements of your project.

Below are the crucial factors to consider:

• Execution Speed: Evaluate the language’s execution speed for critical operations, such as mathematical calculations or data processing, to ensure optimal performance.
• Memory Usage: Assess the language’s memory consumption to determine its efficiency in managing system resources, avoiding excessive memory leaks or overhead.
• Scalability: Consider the language’s ability to scale with increasing workload or user demand, ensuring it can handle growing data volumes or concurrent users effectively.
• Concurrency Support: Evaluate the language’s support for concurrent programming paradigms, such as multithreading or asynchronous processing, to efficiently utilize available hardware resources.
• Optimization Tools: Explore the availability of profiling and optimization tools for the language, enabling developers to effectively identify and address performance bottlenecks during the development and testing phases.

Step 6: Factor in Long-term Viability

Factor in long-term viability involves assessing a programming language’s sustainability and future prospects for your project’s needs. This evaluation considers different factors to ensure that the chosen language remains viable and well-supported in the long run. 

Here are the considerations to take when evaluating long-term viability:

• Language Evolution: Regular updates, new features, and improvements demonstrate a language’s commitment to innovation and relevance to ensure it remains competitive and capable of addressing emerging challenges.
• Adoption Trends: Monitoring a language’s adoption trends and popularity within the industry provides insights into its staying power and potential for continued growth and support.
• Industry Relevance: Consider the language’s relevance and usage across different industries and domains, as widespread adoption and industry support contribute to its stability and long-term viability.
• Backward Compatibility: High level programming languages that prioritize backward compatibility ensure smooth transitions between versions and minimize disruptions to existing projects.

Step 7: Seek Feedback and Recommendations

Seeking feedback and recommendations involves consulting with colleagues, industry peers, and online communities to gather insights and experiences with different high level programming languages. This step is essential because it provides valuable perspectives and recommendations from individuals with diverse backgrounds and experiences to help you make an informed decision. 

Additionally, feedback from experienced developers can offer insights into language suitability, best practices, and potential pitfalls, ultimately guiding you toward selecting the most suitable language for your project.

Example Use Cases for the Different Types of High Level Programming Languages 

High level programming languages are versatile tools that find application across various software development domains. They empower developers to tackle diverse challenges, from web development to data analysis. 

Here are some use cases of high level programming languages with a sample language that exemplifies various sectors:

Web Development

Web development involves building websites and web applications for various purposes, such as e-commerce, social networking, and content management systems. HTML, CSS, JavaScript, and Python are the top web development languages used in these tasks. 

Such languages empower web developers to craft dynamic and interactive web pages, design stylish layouts, and seamlessly implement client-server interactions within the web browser environment.

Data Analysis

Data analysis encompasses examining, cleaning, transforming, and interpreting data to extract meaningful insights and make informed decisions. High-level programming languages like Python and R are widely used. With libraries like Pandas, NumPy, and SciPy (Python), analysts can efficiently manipulate data, perform statistical analysis, and visualize results to derive valuable insights.

Mobile App Development

Mobile app development involves creating applications designed to run on mobile devices like smartphones and tablets. High-level programming languages like Java, Kotlin (for Android), and Swift (for iOS) are commonly used in mobile app development. These languages and their respective development environments and frameworks enable developers to build native apps with rich user interfaces and seamless performance.

Game Development

Game development encompasses designing, developing, and deploying video games for various platforms such as consoles, PCs, and mobile devices. High level programming languages like C++, C#, and JavaScript is often used in this development. Additionally, game engines such as Unity (C#), Unreal Engine (C++), and Phaser (JavaScript) help developers create visually stunning graphics and optimize performance for immersive gaming experiences.

Automation and Scripting

Automation and scripting language involve writing scripts or programs to automate repetitive tasks, streamline workflows, and simplify system administration processes. Most popular languages like Python, Bash, and PowerShell are commonly used for automation and scripting. These languages offer extensive libraries, built-in modules, and command-line interfaces to allow developers to automate data processing, system monitoring, and software deployment tasks efficiently.

Advantages of Using High Level Programming Languages

High level programming languages offer numerous benefits that simplify the development process and enhance productivity. With their user-friendly syntax and built-in features, these languages enable developers to write code more efficiently and focus on solving higher-level problems. Let’s find out some of the advantages of using these languages.

Simplified Syntax

High-level programming languages offer simpler syntax and structures than low-level languages. This helps reduce the complexity of coding tasks and make it easier for developers to write and understand code efficiently. Having this simplicity increases productivity and shorter development cycles, as programmers spend less time wrestling with intricate language intricacies.

Abstraction from Hardware

High level programming languages abstract away the details of hardware architecture, allowing developers to focus on solving higher-level problems. With this benefit, developers can efficiently write code without worrying about low-level memory management or processor instructions. This abstraction enhances portability, as code written in high level languages can be easily adapted to different platforms and environments without significant modifications.

Rich Ecosystem

High level programming languages typically boast extensive libraries, frameworks, and tools that streamline development and provide solutions for everyday tasks. This rich ecosystem accelerates the development process by providing pre-built components and functionalities, allowing developers to leverage existing solutions rather than repeating work.

Increased Developer Productivity

High level languages enhance developer productivity by automating repetitive tasks, offering built-in features, and providing intuitive syntax. This positive nature enables programmers to accomplish more in less time. Simply put, it offers productivity that translates into faster project delivery, reduced time-to-market, and, ultimately, cost savings for businesses.

Accessibility and Community Support

High level programming languages often have large and active developer communities that offer resources, documentation, tutorials, and support forums to help programmers overcome challenges and learn new skills. This accessibility fosters collaboration, knowledge sharing, and continuous improvement within the developer community. Compiling it up, it contributes to the widespread adoption and evolution of high-level languages.

Key Takeaway

Understanding the different high level programming languages requires a strategic approach. Carefully considering your project’s requirements and seeking input from experts can help grasp their nuances and allows you to make informed decisions for your development journey. Remember, choosing the correct language isn’t just about writing code; it’s about setting the stage for innovation, efficiency, and long-term project success. 

So, take the time to explore your options and leverage your resources to propel your projects to new heights. With dedication and intelligent choices, you’ll build great software and cultivate a foundation for continuous growth and advancement in the ever-evolving programming field.

Want to learn more about different high level programming languages? Explore the Aloa blog page for additional insights into selecting the language that aligns with your project goals. Our resources are designed to empower you with knowledge and strategies to ensure your projects succeed and thrive in today’s competitive software landscape.

Aloa is your trusted software development partner.

Trending Articles

Openai codex, gpt 3.5 turbo: 2024 industry insights and guide, 15 excellent sites to hire software developers: a+ list for 2024, 17 top companies and platforms to hire website developers, related categories.

What Are User Stories?

As a startup, should i use firestore for my app, ready to learn more  hire software developers today..

Running a business is hard, Software development shouldn't be ✌️

Sarah Buckley Therapies Ltd

Tailor-made speech and language therapy provision in southeast London

Higher-level language skills by Kate Saunders

What are higher level language skills? Higher level language refers to skills that go beyond basic language abilities. Examples of tasks that require higher level language skills are those that require you to use language to:

• Provide explanations
• Make predictions
• Problem solve
• Look at things from another person’s perspective
• Recognise the difference between literal and non-literal language

Using higher-level language skills can be tricky! Even as an adult there will be times when it can be difficult for us to infer the intended meaning of a message and “read between the lines”. For a child with language difficulties this will be even more challenging and they may need extra support.

Why are these skills important? As a child progresses through school, develops friendships and encounters a range of different social situations, the use of higher level language abilities becomes increasingly important.

Let’s use the example of a literacy lesson at school. After reading a book, a child may be asked to identify how a character is feeling, and what they might say in a specific situation. This information is not immediately obvious and therefore the child will have to use their higher level language skills to look at the situation from the character’s perspective. They then may then be asked to explain how they can tell that the character is feeling that way. This is even trickier! It requires the child to identify the information that has helped them make their inference as well as then explaining their answer in a way that makes sense and includes all of the necessary information.

Let’s look at another example. In a social situation, a child could encounter difficulty if they want to play football but their friend wants to play basketball. This situation requires some problem solving, which is also a higher level language skill. Problem solving involves the ability to recognise the relationship between an action and its outcome. Children who have difficulty determining causes may also find it challenging to predict outcomes.

What can we do to support an individual’s higher level language skills?  Here are a few ideas:

• Think about the types of questions you are asking . Last year, Shelley wrote a post about different levels of questions ( see here for more information ). When we talk about using higher level language, these are the skills that are needed to be able to answer the higher levels of questions. It may be that you need to rephrase your question so that it is not so difficult, or provide additional support if you are asking a higher level question.
• Make thinking skills explicit .   Talk through your thinking skills out loud e.g. “I think the boy must be feeling angry because in the story it said that he shouted and slammed the door”. If you are working from written text, use a highlighter to identify key information and explain how you can use this information to support your thinking skills.
• Relate examples to real-life experiences . It is much easier to learn when we are able to relate examples to something that we have experienced in real life. Let’s think about the question “How do flowers grow?” and let’s relate this to something we know the child has experience of – “remember that time when we planted some flowers? What did we need? What did we do first? Then what happened?”

So, higher level language skills are important! We use these skills in a wide range of different situations and environment, including at school, at home, and when we are out and about. Some children may find it difficult to use these skills by themselves and so we may need to give them a bit of extra support.

Kate Saunders

Speech and Language Therapist

Share this:

• Manage Email Subscriptions
• How to Post to DZone
• Article Submission Guidelines
• Manage My Drafts

A Decade of Kubernetes: Tell us how K8s has impacted your dev journey (and enter for a chance to win $$).

Database Systems: In 2024, the focus around databases is on their ability to scale and perform in modern data architectures. See why.

Data Pipeline Essentials: Dive into the fundamentals of data pipelines and the problems they solve for modern enterprises.

Natural Language Processing: Learn all of the cutting-edge NLP techniques! * Affiliate

• dovpanda: Unlock Pandas Efficiency With Automated Insights
• Dependency Injection
• Build Your Own Programming Language
• 10 Tips To Improve Python Coding Skills in 2024
• Default Map Value
• Building a Semantic Web Search App Using Resource Description Framework and Flask for Cyber Resilience
• Over-Architected? Maybe, Maybe Not
• Transformed Meets the Scrum Guide

Difference Between High-Level and Low-Level Programming Languages

Explore high-level vs. low-level programming languages: abstraction, performance, and more. choose the right one for your coding needs..

Join the DZone community and get the full member experience.

High-level and low-level programming languages are two distinct categories of programming languages used for writing computer programs. They differ significantly in terms of their level of abstraction, ease of use, and the types of tasks they are best suited for. In this extensive discussion, we'll explore the differences between these two language categories in detail.

High-Level Programming Languages

1. abstraction level.

• High-level programming languages are designed with a high level of abstraction. This means that they provide programmers with a set of easy-to-understand and human-readable commands and structures.
• These languages abstract away many of the low-level details of the computer's hardware, making it easier for developers to focus on solving problems rather than managing hardware-specific intricacies.

2. Readability and Ease of Use

• High-level languages are known for their readability and ease of use. Programmers can write code that closely resembles human language, which makes it more accessible to a wider range of developers.
• This readability often leads to shorter development times, as code can be written and maintained more efficiently.

3. Portability

• High-level languages are typically portable, meaning that code written in one high-level language can often be run on different computer architectures or operating systems with minimal modification.
• This portability is facilitated by the use of interpreters or compilers that translate high-level code into machine code or an intermediate representation.

4. Productivity

• High-level languages are designed to enhance programmer productivity. They provide built-in functions and libraries that simplify common tasks.
• Programmers can focus on problem-solving and application logic rather than getting bogged down in low-level details.

5. Examples

• Examples of high-level programming languages include Python, Java , C++, JavaScript, Ruby, and PHP.
• Python, for instance, is known for its simplicity and readability, making it a popular choice for beginners and experienced developers alike.

6. Performance

• High-level languages generally sacrifice some level of performance for ease of use and portability. They rely on interpreters or compilers to convert code into machine code, which can introduce some overhead.
• While high-level languages can be optimized for performance in many cases, they may not be as efficient as low-level languages for certain types of tasks, such as system-level programming.

Low-Level Programming Languages

• Low-level programming languages are closer to the hardware and have a lower level of abstraction. They provide more direct control over the computer's hardware resources.
• Programmers working with low-level languages have to manage memory, registers, and hardware-specific details explicitly.
• Low-level languages are known for their reduced readability and increased complexity. They often involve working with cryptic symbols and require a deep understanding of computer architecture.
• Writing code in low-level languages can be error-prone and time-consuming, as programmers must handle many low-level details.
• Low-level languages are generally not portable. Code written in a low-level language is often specific to a particular computer architecture or operating system.
• To run on different platforms, code must be rewritten or adapted for each target system.
• Low-level languages can be less productive for most application development tasks because they require more effort and time to write and debug.
• They are typically reserved for specialized tasks where fine-grained control over hardware is necessary.
• Examples of low-level programming languages include Assembly language and C.
• Assembly language provides a symbolic representation of machine code instructions, while C offers a higher level of abstraction compared to Assembly but still allows for close control over hardware.
• Low-level languages can deliver superior performance in situations where fine-tuned control over hardware is critical. For tasks like operating system development, device drivers, and embedded systems, low-level languages are often preferred.
• They allow for efficient use of system resources and direct manipulation of memory and hardware registers.

Use Cases and Trade-Offs

High-level languages.

• High-level languages are ideal for a wide range of application development tasks, including web development, data analysis, scientific computing, and more.
• They are the preferred choice for rapid development, prototyping, and projects where performance is not the primary concern.
• High-level languages abstract away complexity, making them suitable for programmers with varying levels of expertise.

Low-Level Languages

• Low-level languages are essential for system-level programming tasks, such as developing operating systems, device drivers, and firmware for embedded systems.
• They are used in situations where absolute control over hardware and maximum performance are required.
• Programmers working with low-level languages typically have a deep understanding of computer architecture and hardware.

Translating Between High-Level and Low-Level Languages

• In practice, it is common to use both high-level and low-level languages within a single project or software ecosystem. This is often achieved through the use of libraries and interfaces.
• High-level languages may include mechanisms for calling functions or using libraries written in low-level languages.
• Conversely, low-level languages may provide ways to interface with high-level languages or use their libraries.
• This mix allows developers to leverage the strengths of each type of language while managing the trade-offs.

Choosing Between High-Level and Low-Level Languages

The choice between high-level and low-level languages depends on the specific requirements of a project:

• If rapid development, readability, and portability are essential, a high-level language is a better choice.
• If maximum control over hardware or high-performance optimization is necessary, a low-level language may be more appropriate.
• In many cases, developers use a combination of both to balance productivity and performance.

High-level and low-level programming languages serve different purposes in the world of software development. High-level languages prioritize ease of use, readability, and portability, making them suitable for a wide range of applications. Low-level languages offer fine-grained control over hardware and exceptional performance, making them indispensable for system-level programming.

The choice between these two types of languages depends on project requirements, with many developers and projects benefiting from a combination of both to harness the advantages of each. Understanding the distinctions between high-level and low-level languages empowers programmers to make informed decisions when selecting the right tool for the job, ultimately leading to more efficient and effective software development.

Opinions expressed by DZone contributors are their own.

Partner Resources

• About DZone
• Send feedback
• Community research
• Advertise with DZone

CONTRIBUTE ON DZONE

• Become a Contributor
• Core Program
• Visit the Writers' Zone
• Terms of Service
• Privacy Policy
• 3343 Perimeter Hill Drive
• Nashville, TN 37211
• [email protected]

Let's be friends:

• Python Course
• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Why Python is a High Level Language

Python is categorized as a high-level programming language because of several key characteristics and features that distinguish it from lower-level languages ​​such as assembly language or machine code. In this article, we will see why Python is a high-level language.

What Does High-Level Language Mean?

High-level languages ​​are programming languages ​​designed to be without problems understood and written by way of people, absorbing the complexity of low-level gadget functions These languages’ ​​cognizance of , expressing algorithms and information toward herbal language compliance, making it less complicated for programmers to achieve this is software program development

High-degree languages ​​offer numerous great benefits over low-stage languages ​​such as assembly or machine code. First, they provide abstraction from hardware, permitting programmers to write down code that is independent of precise processor architectures or operating systems. This portability allows software programs written in high-stage languages ​​to run throughout systems without modification, increasing flexibility and reducing development time

Second, excessive degree languages ​​emphasize studying and expressiveness in their syntax and shape. They use familiar constructs and key phrases that resemble human language, making the code easier to apprehend and maintain. This clarity now not most effective reduces the possibility of mistakes however additionally increases collaboration among builders running at the same challenge.

What Makes Python a High-level Programming Language?

Python is a high-level programming language because of several key characteristics and features that distinguish it from lower-level languages ​​like assembly language or machine code Here are the main reasons why Python is categorized as a high-level language:

Abstract Machine Description

Python abstracts complex computer hardware and low-level system interactions and lets developers concentrate on problem solving tasks at higher levels of abstraction. Instead of dealing with memory management, processor registration or hardware specific instructions, Python programmers employ constructs that resemble natural language and human thought.

Readable & Transparent Syntax

The intention behind the design of Python syntax is to make it readable and understandable so that developers can write code more easily. Indentation in a Python program defines blocks, which enhances readablility and reduces the need for explicit delimiters like braces or semicolons. Furthermore, concise and clear syntax allows developers to express complex ideas in a simple logical way

Extensive Standard Library

Python provides a comprehensive set of standard libraries that provide many pre-built modules and functions for common programming tasks These libraries abstract away low-level implementation details and provide high-level APIs for file I/1. O, networking , database access, etc. Who can write great code and could focus on solving higher level problems.

Automated Memory Management

Automatic memory management known as garbage collection is implemented in python. As a result, we don’t need ma For this reason; automatic memory management feature has been introduced in Python which relieves the programmer from having to take care of memory allocation/deallocation issues manually by using keywords such as malloc, calloc or free

Platform Independence

Python is platform-independent, which means that Python code can run in different operating ystems without modification. This is achieved through the use of an interpreter, which translates Python code into machine-readable bytecode that can be executed on any platform that has a compatible Python interpreter installed. This platform independence enables developers to write code once and deploy it across multiple platforms, increasing productivity and reducing development time.

Why Developers are Fond of Python?

Developers like Python for a number of reasons including its simplicity and readability, versatility and large ecosystem. Here are some of the main reasons for Python’s popularity among developers:

Simplicity and Readability

Python’s syntax is clean, intuitive, and easy to read, making it accessible to developers of all skill levels. Its use of indentation to define code blocks encourages consistent and readable code, reducing the cognitive load and making it easier to understand and maintain codebases.

Versatility

Python is a versatile language that can be used for a wide range of applications, including web development, data analysis, artificial intelligence, machine learning, scientific computing, automation, and more. Its versatility allows developers to use Python for various projects without needing to switch to different languages or frameworks.

Vast Ecosystem of Libraries & Frameworks

Python has a rich ecosystem of third-party libraries and frameworks that provide solutions for almost any programming task or domain. From Django and Flask for web development to NumPy and pandas for data analysis, Python’s extensive library ecosystem accelerates development and reduces the need to reinvent the wheel.

Community and Support

Python has a large and active community of developers who contribute to its development, create open-source projects, and provide support through forums, online communities, and documentation. The Python community is known for its inclusivity, collaboration, and willingness to help newcomers, making it easy for developers to find resources, tutorials, and assistance when needed.

Cross-Platform Compatibility

Python is a cross-platform language, meaning that code written in Python can run on various operating systems without modification. This allows developers to write code once and deploy it across different platforms, including Windows , macOS, Linux, and more, increasing productivity and reducing development time.

Ease of Learning and Teaching

Python’s simplicity and readability make it an ideal language for beginners to learn programming. Its gentle learning curve and beginner-friendly syntax enable newcomers to quickly grasp fundamental programming concepts and start building projects. Additionally, Python is widely used in educational settings and has extensive documentation and resources for learning.

In conclusion, Python is considered a High Level programming language because it strips away low-level information, emphasizes readability and simplicity, provides a nice standard library, uses automatic memory management, and is not platform-independent Those characteristics this makes Python ideal for many application applications.

Please Login to comment...

Similar reads.

• Python Blog
• How to Get a Free SSL Certificate
• Best SSL Certificates Provider in India
• Elon Musk's xAI releases Grok-2 AI assistant
• What is OpenAI SearchGPT? How it works and How to Get it?
• Content Improvement League 2024: From Good To A Great Article

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings

curiousbrutus/Problem-Solving-with-High-Level-Languages

Folders and files.

Repository files navigation

Problem-solving-with-high-level-languages.

This is the repository for -> This folder contains the files I was working on to gain problem solving skills in different languages.

I practiced and enjoyed it very much.

Source: Assignments are published at http://pages.github.uio.no/IN3110/assignments/assignments/

• Python 98.1%
• Cython 0.8%
• Fortran 0.0%

PrepBytes Blog

ONE-STOP RESOURCE FOR EVERYTHING RELATED TO CODING

Sign in to your account

Forgot your password?

Login via OTP

We will send you an one time password on your mobile number

An OTP has been sent to your mobile number please verify it below

Register with PrepBytes

High-level langauge.

Last Updated on August 9, 2023 by Mayank Dham

High-level programming languages have revolutionized the way we develop software applications. These languages enable developers to craft code that closely resembles human language, simplifying the processes of comprehension, composition, and upkeep. This composition explores the realm of high-level languages, delving into their merits and demerits, and providing instances of such languages.

What is High-Level Language?

High-level programming languages empower individuals to create computer programs and engage with computer systems without requiring knowledge of the specific processor or hardware on which the program will execute.

High-level languages use command words and syntax that are similar to everyday language, making them easier to learn and apply. High-level languages also provide developers with development tools like libraries and built-in functions.

High-Level Language Examples

Here we have high-level languages examples which are C, C++, Java, Python, Javascript, etc

C was created in order to create the UNIX operating system. C is also a portable language, which means that programs written in C can be compiled to run on different platforms and operating systems. This is possible because C compilers are available for many different architectures and operating systems. C is the successor to the B language, which was first introduced in the early 1970s. The American National Standard Institute formalized the language in 1988. (ANSI). The UNIX operating system was entirely written in C. Today, C is the most popular and widely used System Programming Language. The majority of cutting-edge software has been written in C. The most popular Linux operating system and RDBMS, MySQL, were written in C.

C++ is a statically typed, compiled, general-purpose, case-sensitive, free-form programming language that can be used to write procedural, object-oriented, and generic code.C++ is classified as a middle-level language because it combines high-level and low-level language features.

C++ was created by Bjarne Stroustrup in 1979 at Bell Labs in Murray Hill, New Jersey, as an enhancement to the C language. It was initially called C with Classes before being renamed C++ in 1983.C++ is a superset of C, which means that almost any legal C program is also a legal C++ program. C++ supports object-oriented programming, allowing developers to create classes and objects, as well as define methods and properties for these objects. Templates: C++ templates enable developers to write generic code that can work with any data type, making reusable and flexible code easier to write. STL (Standard Template Library): The STL provides a diverse set of data containers and algorithms, making it easier to write efficient and effective code.

Java is a high-level, object-oriented programming language that was originally developed by Sun Microsystems (now owned by Oracle Corporation) in the mid-1990s. It is designed to be platform-independent, which means that programs written in Java can run on any platform that supports a Java Virtual Machine (JVM).

Java is widely used for developing enterprise applications, web applications, and mobile applications. It provides a rich set of libraries and frameworks that make it easy to develop complex applications. Some of the key features of Java include automatic memory management, garbage collection, and exception handling.

Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built-in data structures, combined with dynamic typing and dynamic binding, make it very desirable for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python’s simple, easy-to-learn syntax emphasizes readability, lowering the cost of program maintenance. Python supports modules and packages, which promotes program modularity and code reuse. The Python interpreter and extensive standard library are freely distributable and available in source or binary form for all major platforms.

5) Javascript

JavaScript is a dynamic computer programming language. It is lightweight and is most commonly used as part of web pages, where implementations allow client-side script to interact with the user and create dynamic pages. It is an interpreted programming language with object-oriented capabilities.

JavaScript was originally known as LiveScript, but Netscape changed its name to JavaScript, possibly due to the excitement generated by Java. JavaScript first appeared in Netscape 2.0 in 1995 as LiveScript. The language’s general-purpose core has been embedded in Netscape, Internet Explorer, and other web browsers.

All these are high-level language examples.

Advantages of High-Level Language

Below we have the advantages of High-Level Programming Languages are:

• Abstraction and Simplification: High-level languages provide a higher level of abstraction, allowing programmers to focus on the logic and functionality of their programs rather than the intricate details of hardware or low-level operations.
• Readability and Maintainability: Code written in high-level languages is often more readable and understandable, making it easier for programmers to collaborate, debug, and maintain software projects over time.
• Productivity: High-level languages offer built-in functions, libraries, and frameworks that expedite the development process. This boosts productivity and enables faster creation of complex applications.
• Portability: Programs written in high-level languages are generally more portable, as they are not tightly bound to a specific hardware architecture. This allows code to be executed on different platforms with minimal modifications.
• Reduced Errors: The abstraction and automation provided by high-level languages reduce the likelihood of human errors, such as memory management issues, that are common in low-level languages.
• Rapid Development: High-level languages often provide features like dynamic typing, automatic memory management, and concise syntax, enabling rapid prototyping and development of software applications.
• Community and Resources: Popular high-level languages have large and active communities, resulting in extensive documentation, tutorials, and online resources that aid programmers in learning and problem-solving.
• Enhanced Security: Many high-level languages include security features and mechanisms that help prevent common vulnerabilities, contributing to safer software development.
• Easier Learning Curve: High-level languages are typically easier to learn for newcomers to programming, as they abstract away low-level complexities and allow beginners to focus on coding concepts and problem-solving.

Disadvantages of High-Level Language

Below we have the disadvantages of High-Level Programming Languages are:

• Slower execution: High-level languages are generally slower than low-level languages, as they require more processing time to convert their code into machine code.
• Less control: High-level languages abstract away low-level details and hardware-specific functions, making it difficult to optimize code for specific hardware or systems.
• Higher memory usage: High-level languages require more memory than low-level languages, as they use additional functions and structures to provide more organization and structure to code.

Conclusion We can conclude that high-level programming languages have revolutionized the way we develop software applications. They offer many advantages over low-level languages, including ease of use, portability, and efficiency. However, they also have some disadvantages, such as slower execution and higher memory usage. It is important to choose the right programming language for a particular project, taking into account its advantages and disadvantages, and the specific needs of the application high level language examples are C++, Ruby, Javascript, Java, Python, C, etc

Frequently Asked Questions(FAQs)

Here are some FAQs on high-level language:

Q1. What are some common applications of high-level programming languages? Ans: High-level programming languages are used for a wide variety of applications, including web development, scientific computing, data analysis, artificial intelligence, and video game development.

Q2. How do high-level programming languages compare to low-level programming languages? Ans: High-level programming languages are easier to learn and use than low-level languages, but they generally have reduced performance and increased memory usage compared to low-level languages. Low-level languages provide more control over hardware and can be more efficient in certain applications.

Q3. What resources are available for learning high-level programming languages? Ans: There are many resources available for learning high-level programming languages, including online courses, tutorials, documentation, and online communities such as forums and chat groups.

Q4. Can high-level programming languages be used for system programming? Ans: High-level programming languages can be used for system programming, but they may not be the best choice for low-level tasks such as writing device drivers or operating system kernels. However, some high-level languages, such as C and C++, are commonly used for system programming.

Q5. What is the difference between a high-level language and a low-level language? Ans: High-level languages are designed to be easier to read and write, with a syntax that is closer to human language. They generally provide more abstraction and automation, allowing programmers to focus on solving problems rather than low-level details. Low-level languages, on the other hand, are designed to be closer to machine language, providing more control over hardware and allowing for greater performance and efficiency.

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.

• Linked List
• Segment Tree
• Backtracking
• Dynamic Programming
• Greedy Algorithm
• Operating System
• Company Placement
• Interview Tips
• General Interview Questions
• Data Structure
• Other Topics
• Computational Geometry
• Game Theory

Related Post

What is the main difference between structured and unstructured data, difference between microprocessor and microcontroller, difference between composition and inheritance, digital signature in cryptography, web server: functions, architecture and types, 8051 microcontroller architecture.

Creative Problem Solving in Large Language and Vision Models – What Would it Take?

We advocate for a strong integration of Computational Creativity (CC) with research in large language and vision models (LLVMs) to address a key limitation of these models, i.e., creative problem solving. We present preliminary experiments showing how CC principles can be applied to address this limitation. Our goal is to foster discussions on creative problem solving in LLVMs and CC at prestigious ML venues.

Lakshmi Nair Georgia Institute of Technology Atlanta, GA, USA                        Evana Gizzi Tufts University Medford, MA, USA                        Jivko Sinapov Tufts University Medford, MA, USA

1 Introduction

Creativity is “ …the ability to come up with an idea which, relative to the pre-existing domain-space in one’s mind, one could not have had before. Whether any other person (or system) has already come up with it on an earlier occasion is irrelevant. ” Boden ( 1998 ) , p.216. For artificial agents, Computational Creativity (CC) is a multi-disciplinary field (spanning Philosophy, Psychology, Neuroscience, and Computer Science) that seeks to develop computational methods capable of generating creative outcomes reminiscent of creative processes in humans Gizzi et al. ( 2022 ) . Within CC, creative problem solving is a sub-area that requires an agent to discover – from its perspective – novel and previously unseen ways to accomplish a task. For example, in the absence of a ladle to scoop ingredients, an agent might creatively choose to substitute a bowl in place of the ladle. In this sense, creative problem solving encompasses creativity that is specifically task-oriented , as opposed to the generation of creative artifacts e.g., music or images.

While recent state-of-the-art large language models (LLMs) and vision-language models (VLMs) have demonstrated competency in artistic endeavours Rombach et al. ( 2021 ); Copet et al. ( 2023 ) , creative problem solving continues to be a shortcoming of these models (we use LLVM to denote the umbrella of both LLMs and VLMs). For instance, in Bubeck et al. ( 2023 ) , the authors point out that “discontinuous tasks” that require a certain “Eureka” idea, i.e., creative problem solving, is currently a limitation of models like GPT-4. Similar observations have been made in follow up work showing that state-of-the-art LLMs inherently possess poor creative problem solving capabilities compared to humans Tian et al. ( 2023 ); Naeini et al. ( 2023 ) . Given this obvious limitation, ongoing research in Machine Learning should seek to address the gap between LLVMs and creative problem solving, to further enhance the intelligent capabilities of these models. As defined in prior work, “ Intelligence is the ability to work and adapt to the environment with insufficient knowledge and resources. ” Pennachin and Goertzel ( 2007 ) , p.10. Demonstrated in hallmark examples of human ingenuity, like the makeshift C ⁢ O 2 𝐶 subscript 𝑂 2 CO_{2} italic_C italic_O start_POSTSUBSCRIPT 2 end_POSTSUBSCRIPT filter built onboard the Apollo-13 Cass ( 2005 ) , or the makeshift medical devices used to offset equipment shortages during COVID-19 Turner et al. ( 2020 ) , creative problem solving is especially important when dealing with resource-critical scenarios. Since humans may tend to “choke” under high pressure situations DeCaro et al. ( 2011 ) often limiting their CPS skills, autonomous agents equipped with LLVMs that have similar capabilities would be highly assistive and transformative to humans in high-stake environments. These include situations like rescue missions BBC ( 2012 ) or autonomous operation in human-inaccessible environments (e.g., space or underwater exploration) with limited resources Atkeson et al. ( 2018 ) . However, the exceptional degree of creative problem solving necessary for such assistance remains beyond the scope of LLVMs today, limiting their intelligence (See Appx. B.1 ).

We believe that a discussion of Computational Creativity is essential to addressing this limitation. It is our position that Machine Learning and Computational Creativity should be strongly integrated in research to enable effective creative problem solving in LLVMs and push the frontiers of their ingenuity.

2 Two Cultures Problem: Why does CC not receive a wider reception in ML?

Even though creative problem solving (CPS) is a shortcoming of existing LLVMs, Computational Creativity seldom finds its way into mainstream ML research. We believe this discrepancy aligns with the “two cultures” problem Hammond et al. ( 2013 ) (also corroborated in Van Heerden and Bas ( 2021 ); Lahikainen et al. ( 2024 ) ), and is motivated by three aspects of CC literature as it relates to creative problem solving: a) the lack of a precise definition of CPS makes it challenging to identify how existing approaches in LLVMs are deficient in CPS skills; b) the somewhat “abstract” computational descriptions of CPS in Computational Creativity is challenging to connect to practical algorithms in LLVMs; and c) the lack of standardized benchmarks make it harder to evaluate LLVMs for CPS. In our discussions relating to a) in Section 3.1 , b) in Section 4 , and c) Section 5 , we hope to address these gaps and encourage the ML community to think about how LLVMs can be augmented with creative problem solving skills through a deeper discussion of Computational Creativity.

To emphasize the applicability of principles from CC for creative problem solving in LLVMs, we discuss the seminal work of Margaret A. Boden from CC literature that introduces three forms of creativity, namely, “ exploratory ”, “ combinational ”, and “ transformational ” Boden ( 1998 ) . Prior work has discussed the extension of Boden’s forms of creativity to creative problem solving in AI Gizzi et al. ( 2022 ) , however, their work does not include recent advances in LLVMs nor how Boden’s principles can be extended to specific approaches for LLVMs.

Ongoing discussions by leading ML experts like Dr. Shane Legg, co-founder of DeepMind, have suggested that “search” could help such models perform creative problem solving, quote, “ … these foundational models are world models of a kind, and to do really creative problem solving, you need to start searching ” Patel ( 2023 ) . There has also been speculation that OpenAI’s Q ∗ superscript 𝑄 Q^{*} italic_Q start_POSTSUPERSCRIPT ∗ end_POSTSUPERSCRIPT search (described as a “significant breakthrough” in popular media) could be targeting a similar approach Wang ( 2023 ); Anna Tong and Hu ( 2023 ) . Interestingly, we note that “search” as described here, can be linked to Boden’s proposed “exploratory” approach (Section 4.1.1 ). However, in Section 4 , we posit that “combinational” and “transformational” modes should be equally emphasized to achieve creative problem solving in LLVMs.

Although we choose to expand on Boden’s work as the focal point to drive our arguments in the main paper, it is not the only theory in CC that is relevant to this discussion. For completeness, we elaborate on additional CC theories and their applicability to creative problem solving in LLVMs in Appx. B .

3 From Task Planning to Creative Problem Solving

Creative problem solving can be broadly described as the process through which agents discover novel ways of accomplishing a task that, prior to the discovery, was unsolvable. Computationally, creative problem solving can be achieved through planning, learning, or hybrid approaches Gizzi et al. ( 2022 ) . Following a review of the different definitions of creative problem solving that have been proposed (Appx. A ), we believe the following most closely connects to existing formalisms in ML.

3.1 Definition of Creative Problem Solving

Gizzi et al. ( 2022 ) define the notion of a concept , as a state (of the environment and/or agent) or action. More generally, the authors denote C X subscript 𝐶 𝑋 C_{X} italic_C start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT as the set of all concepts relating to X 𝑋 X italic_X ( X 𝑋 X italic_X denotes environment states S 𝑆 S italic_S or actions A 𝐴 A italic_A ). Hence, C S subscript 𝐶 𝑆 C_{S} italic_C start_POSTSUBSCRIPT italic_S end_POSTSUBSCRIPT denotes the set of all environmental states, and C A subscript 𝐶 𝐴 C_{A} italic_C start_POSTSUBSCRIPT italic_A end_POSTSUBSCRIPT denotes the set of agent actions. Formally, the authors state their definition as (Page 7, (Gizzi et al., 2022 ) ):

Given an un-achievable goal due to an insufficient conceptual space, CPS refers to the process by which the agent discovers a new conceptual space C X ′ ⊈ C X not-subset-of-nor-equals subscript superscript 𝐶 ′ 𝑋 subscript 𝐶 𝑋 C^{\prime}_{X}\nsubseteq C_{X} italic_C start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT ⊈ italic_C start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT , such that C X ′ = f ⁢ ( C X ) subscript superscript 𝐶 ′ 𝑋 𝑓 subscript 𝐶 𝑋 C^{\prime}_{X}=f(C_{X}) italic_C start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT = italic_f ( italic_C start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT ) is the result of applying some function f 𝑓 f italic_f on the current conceptual space, enabling the agent to solve the previously unsolvable task by using C X ′ subscript superscript 𝐶 ′ 𝑋 C^{\prime}_{X} italic_C start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT .

As a simplified example, let us assume a robot that has a goal G 𝐺 G italic_G of transferring beans from a jar to a cooker: G = 𝐺 absent G= italic_G = { i ⁢ n 𝑖 𝑛 in italic_i italic_n (beans, cooker)}. Here, the initial state is defined as C S = subscript 𝐶 𝑆 absent C_{S}= italic_C start_POSTSUBSCRIPT italic_S end_POSTSUBSCRIPT = { i ⁢ n 𝑖 𝑛 in italic_i italic_n (beans, jar), h ⁢ a ⁢ s ⁢ C ⁢ o ⁢ n ⁢ t ⁢ a ⁢ i ⁢ n ⁢ a ⁢ b ⁢ i ⁢ l ⁢ i ⁢ t ⁢ y ℎ 𝑎 𝑠 𝐶 𝑜 𝑛 𝑡 𝑎 𝑖 𝑛 𝑎 𝑏 𝑖 𝑙 𝑖 𝑡 𝑦 hasContainability italic_h italic_a italic_s italic_C italic_o italic_n italic_t italic_a italic_i italic_n italic_a italic_b italic_i italic_l italic_i italic_t italic_y (spoon)}. Let the actions be defined as C A = subscript 𝐶 𝐴 absent C_{A}= italic_C start_POSTSUBSCRIPT italic_A end_POSTSUBSCRIPT = { s ⁢ c ⁢ o ⁢ o ⁢ p 𝑠 𝑐 𝑜 𝑜 𝑝 scoop italic_s italic_c italic_o italic_o italic_p (beans, X 𝑋 X italic_X , l ⁢ o ⁢ c s 𝑙 𝑜 subscript 𝑐 𝑠 loc_{s} italic_l italic_o italic_c start_POSTSUBSCRIPT italic_s end_POSTSUBSCRIPT , l ⁢ o ⁢ c d 𝑙 𝑜 subscript 𝑐 𝑑 loc_{d} italic_l italic_o italic_c start_POSTSUBSCRIPT italic_d end_POSTSUBSCRIPT )}, where, X 𝑋 X italic_X refers to an object that satisfies h ⁢ a ⁢ s ⁢ C ⁢ o ⁢ n ⁢ t ⁢ a ⁢ i ⁢ n ⁢ a ⁢ b ⁢ i ⁢ l ⁢ i ⁢ t ⁢ y ⁢ ( ⋅ ) ℎ 𝑎 𝑠 𝐶 𝑜 𝑛 𝑡 𝑎 𝑖 𝑛 𝑎 𝑏 𝑖 𝑙 𝑖 𝑡 𝑦 ⋅ hasContainability(\cdot) italic_h italic_a italic_s italic_C italic_o italic_n italic_t italic_a italic_i italic_n italic_a italic_b italic_i italic_l italic_i italic_t italic_y ( ⋅ ) (e.g., spoon), to scoop beans from l ⁢ o ⁢ c s 𝑙 𝑜 subscript 𝑐 𝑠 loc_{s} italic_l italic_o italic_c start_POSTSUBSCRIPT italic_s end_POSTSUBSCRIPT to l ⁢ o ⁢ c d 𝑙 𝑜 subscript 𝑐 𝑑 loc_{d} italic_l italic_o italic_c start_POSTSUBSCRIPT italic_d end_POSTSUBSCRIPT . If the robot has access to a spoon, the robot can use it to scoop the beans from the jar to the cooker. However, what if the robot did not have a spoon, but had a glass instead? By the definition of C S subscript 𝐶 𝑆 C_{S} italic_C start_POSTSUBSCRIPT italic_S end_POSTSUBSCRIPT , the agent is unaware that h ⁢ a ⁢ s ⁢ C ⁢ o ⁢ n ⁢ t ⁢ a ⁢ i ⁢ n ⁢ a ⁢ b ⁢ i ⁢ l ⁢ i ⁢ t ⁢ y ℎ 𝑎 𝑠 𝐶 𝑜 𝑛 𝑡 𝑎 𝑖 𝑛 𝑎 𝑏 𝑖 𝑙 𝑖 𝑡 𝑦 hasContainability italic_h italic_a italic_s italic_C italic_o italic_n italic_t italic_a italic_i italic_n italic_a italic_b italic_i italic_l italic_i italic_t italic_y (glass) is true, making the goal un-achievable. By our definition, creative problem solving is the process by which the agent uses some function f ⁢ ( ⋅ ) 𝑓 ⋅ f(\cdot) italic_f ( ⋅ ) to discover a new conceptual space: f ⁢ ( C S ) = C S ′ = C S ⁢ ∪ 𝑓 subscript 𝐶 𝑆 subscript superscript 𝐶 ′ 𝑆 subscript 𝐶 𝑆 f(C_{S})=C^{\prime}_{S}=C_{S}\mathop{\cup} italic_f ( italic_C start_POSTSUBSCRIPT italic_S end_POSTSUBSCRIPT ) = italic_C start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_S end_POSTSUBSCRIPT = italic_C start_POSTSUBSCRIPT italic_S end_POSTSUBSCRIPT ∪ { h ⁢ a ⁢ s ⁢ C ⁢ o ⁢ n ⁢ t ⁢ a ⁢ i ⁢ n ⁢ a ⁢ b ⁢ i ⁢ l ⁢ i ⁢ t ⁢ y ℎ 𝑎 𝑠 𝐶 𝑜 𝑛 𝑡 𝑎 𝑖 𝑛 𝑎 𝑏 𝑖 𝑙 𝑖 𝑡 𝑦 hasContainability italic_h italic_a italic_s italic_C italic_o italic_n italic_t italic_a italic_i italic_n italic_a italic_b italic_i italic_l italic_i italic_t italic_y  (glass)}. This would allow the agent to solve the previously unsolvable task by using the glass to scoop the beans instead.

Boden’s three forms of creativity denote three plausible functions for f ⁢ ( C X ) 𝑓 subscript 𝐶 𝑋 f(C_{X}) italic_f ( italic_C start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT ) . CPS arises when the agent uses what it knows, to discover something new and the newly discovered knowledge is applied to solve a previously impossible task. We revisit the notion of conceptual spaces in Section 3.

In the remainder of this section, we discuss how typical task planning is achieved with LLVMs. We divide the discussion into three subsections based on the level of task planning abstraction where LLVMs are applied: a) high-level task planning, b) low-level task planning, and c) hybrid task planning. While not exhaustive, our review is meant to offer a general insight into how LLVMs are used for task planning, to identify entry points for introducing creative problem solving capabilities.

3.2 LLVMs for high-level task planning

Approaches for high-level task planning often involve using LLVMs to identify high-level goals for accomplishing a task. Some approaches to task planning with LLMs often take a user input specifying the task, and generate high-level task plans for accomplishing it. These approaches often use LLMs as a form of “knowledge base”, to extract actionable task plans from the models via appropriate prompting Huang et al. ( 2022 ) , further iterating over the generated task plan with repeated calls to the LLM as needed Prasad et al. ( 2023 ) .

In the context of Reinforcement Learning (RL), prior work has focused on using LLMs to suggest high-level goals for an RL agent Du et al. ( 2023 ) . Dubbed as ELLMs (Exploring with LLMs), an RL agent provides its current state to an LLM via a prompt, and receives a goal suggestion from the LLM that is then used to shape the reward and the agent exploration. Further work has extended this approach to incorporate the use of experience memory Zhang et al. ( 2023a ) . Existing approaches have also used LLMs to generate directed acyclic graphs composed of sub-goal states to aid the exploration of an RL agent Shukla et al. ( 2023 ) .

3.3 LLVMs for low-level task planning

Approaches for low-level task planning involve using LLMs to generate low-level code for performing a task. In contrast to high-level planning, where high-level goals and sub-goals are generated, these approaches use LLMs to directly generate low-level execution code via appropriate API calls Liang et al. ( 2023 ) . Other approaches have also investigated the capacity of LLMs to generate task plans via a low-level planning language such as PDDL Silver et al. ( 2023 ) , including iterating over the generated plan descriptions in case of errors Guan et al. ( 2023 ) . In terms of low-level planning using VLMs, prior work has introduced an approach that uses a diffusion model to generate robot trajectories conditioned on language and the current visual state of the robot Chen et al. ( 2023 ) .

3.4 Hybrid high and low-level planning with LLVMs

Hybrid approaches use LLVMs both for high-level goal generation as well as low-level planning. For instance, in Li et al. ( 2023 ) , user inputs are passed as LLM prompts to generate high-level plans. The high-level plans are then converted to low-level plans for robot execution via LLMs specialized for coding. Other approaches have used a high-level LLM planner, a VLM perceiver, and a low-level LLM planner for re-planning with both visual and language inputs Skreta et al. ( 2024 ) .

3.5 Summary

Given this overview, we see that LLVMs both at the high-level and low-level, can be modified to incorporate creative problem solving into task planning. For instance, the high-level task plans generated can encompass a novel substitution for a missing object, whereas the low-level task plan can generate an appropriate trajectory for creatively using the object. While the above approaches could, in principle, be studied within the framework of creative problem solving, that is not usually how the problem is formulated; there is a lack of paradigms for studying creative problem solving beyond just, “do you solve the problem or not?” . Creative problem solving needs a fundamental rethinking of the typical problem formulations and approaches in ML. The next section is aimed at ways in which ML approaches in LLVMs can be reformulated from the perspective of CC.

4 Augmenting LLVM embedding spaces for creative problem solving

In this section, we discuss how principles from CC can be extended to LLVMs for creative problem solving. We begin with Boden’s definition of “conceptual spaces” as “ [conceptual space] is the generative system that underlies the domain and defines a certain range of possibilities: chess moves, or molecular structures, or jazz melodies ” Boden ( 2005 ) , p.18 and “ … in short, any reasonably disciplined way of thinking ” Boden ( 1998 ) , p.214. By this definition, the embedding space of an LLVM describes its conceptual space or “ its way of thinking ”. Some evidence for this also comes from existing work that introduces an approach for enabling LLMs to interpret continuous embedding spaces via natural language. Given an embedding vector representing an interpolation of different concepts, the model is able to interpret a text prompt in the context of the supplied embedding Tennenholtz et al. ( 2023 ) . The embedding thus determines the model’s way of thinking. Hence, a discussion of enabling creative problem solving in LLVMs should target their embedding space. To this end, we explore two questions: a) how can LLVM embedding spaces be augmented to achieve creative problem solving, and b) what information should they be augmented with? Aligning with our original position, we show that CC literature can offer insights into these questions.

4.1 How can LLVM embedding spaces be augmented?

In this section, we draw parallels between Boden’s three forms of creativity and existing approaches in LLVMs. We further elaborate on how the three forms of creativity may enhance the potential of LLVMs to perform creative problem solving. We note that the ML approaches discussed in this section do not specifically perform creative problem solving. However, we discuss how they could potentially be extended to do so, by leveraging references from the CC literature.

4.1.1 Exploratory Creativity

Exploratory approaches involve exploration within the conceptual or equivalently, the embedding space of the model, and most closely relates to “search”. Note that the term “exploration” here differs from its usage in RL, instead referring to exploration through the model’s embedding space . Several existing approaches in the ML literature involve searching the output space of LLMs with the goal of improving the performance of these models. The “tree-of-thought” model generates a “tree” of next possible LLM outputs, and searches through the states via Breadth-first or Depth-first search to reach the desired goal state, often guided by heuristics Yao et al. ( 2023 ) . Numerous other approaches have built upon a similar strategy, such as using Monte-Carlo Tree Search (MCTS) Zhou et al. ( 2023 ); Feng et al. ( 2023 ) , beam search Zhang et al. ( 2023b ) or integrating pruning to remove sub-par candidates Golovneva et al. ( 2023 ) .

Extension of exploratory creativity to LLVMs: An important point to note here is that these approaches involve searching exclusively within the output “solution space” of the LLMs rather than directly operating in the embedding space itself. In contrast to operating in the solution space of the LLM, exploratory approaches directly within the LLMs’ embedding space would not be limited by what the LLM can generate as output – “ Some exploration merely shows us the nature of the relevant conceptual space that we had not explicitly noticed before ” Boden ( 2005 ) , p.18. To effectively reveal the full extent of the conceptual space for creative problem solving, the approach should not be limited by the outputs the LLVM can generate. Rather, the generated (creative) outputs itself should be the result of heuristic or non-heuristic based search within the model’s embedding space. However, to the best of our knowledge current approaches have not focused on LLVMs from this perspective, and have also not applied search to embedding spaces of Vision-LMs. Regardless, exploratory approaches are still limited by the dimensions of the model’s embedding space. “ To overcome a limitation in the conceptual space, one must change it in some way ” Boden ( 2005 ) , p.18 - this leads us to combinational and transformational creativity.

4.1.2 Combinational Creativity

Combinational approaches involve combining two concepts to create something new - “ A novel combination of two familiar ideas is something which did not happen before. ” Boden ( 1998 ) , p.213. We can broadly translate this to a function that takes in multiple concepts within an LLVM’s embedding space to output a novel concept.

One way of extending this definition to LLVMs involves applying cross-attention layers. The attention operation is defined as Vaswani et al. ( 2017 ) :

where, Q 𝑄 Q italic_Q , K 𝐾 K italic_K and V 𝑉 V italic_V denote query, keys and values respectively, and d k subscript 𝑑 𝑘 d_{k} italic_d start_POSTSUBSCRIPT italic_k end_POSTSUBSCRIPT denotes the dimensionality of the keys. Cross-attention involves passing K 𝐾 K italic_K and V 𝑉 V italic_V from a different model, e.g., in Flamingo Alayrac et al. ( 2022 ) , the keys and values represent visual input (from a separate vision encoder) and queries represent a language input. By applying cross attention in this manner, the embedding space of a model can be extended with capabilities of another model. In Bansal et al. ( 2024 ) the authors show that using cross-attention layers can help augment an anchor LLM with an augmenting LLM’s capabilities to perform a task that the anchor LLM was incapable of achieving before - hinting at some creative possibilities of this method.

Other approaches in LLVMs, while using “combinations” in some way, do not conform to the notion of combinational creativity . This includes, for instance, approaches that perform arithmetic combination of LLM weights to enhance the model performance Matena and Raffel ( 2022 ); Ilharco et al. ( 2022 ) . Or approaches that combine image and text embeddings via concatenation Kim et al. ( 2021 ) or a scaled dot product at the output Radford et al. ( 2021 ) . While these approaches may be useful in imparting multi-modal capabilities, however, they do not lead to combinational creativity since the combination occurs external to the models as opposed to within the model’s embedding space.

Extension of Combinational Creativity to LLVMs: The ML approaches described here involve combining embedding spaces across models. Existing approaches have not looked at combining concepts within the same model’s embedding space. The extension of combinational creativity to LLVMs is much more apparent in the sense of conceptual blending Fauconnier and Turner ( 2003 ) for generation of creative artifacts, e.g., via blending of artistic styles. However, the extension of combinational creativity to creative problem solving is less obvious, and CC literature offers us further insights for making this connection. Typical conceptual blending corresponds to a form of “aesthetic combination”, whereas creative problem solving would benefit from “functional combinations” Chen et al. ( 2018 ) . Functional combination combines the functions (as opposed to aesthetic) of two components, e.g., a coin combined with pliers could function as a makeshift screwdriver. The authors extend this framework to a combination of two nouns with a “base” noun (e.g., “pliers”) and “additive” noun (e.g., “coin”). An interesting possibility stems from this notion: Can a combination of embeddings of the same LLVM, corresponding to “base” and “additive” nouns (perhaps with some prior denoting the task), enable the LLVM to generate creative combinations of objects for solving a task? This question remains unexplored, and points to a potential research direction for LLVMs inspired by CC.

4.1.3 Transformational Creativity

Transformational approaches involve transforming existing conceptual spaces to produce new ones. Transforming conceptual spaces can involve “ altering existing rules ” Boden ( 1998 ) , p.216. One way of transforming a model’s embedding space involves fine-tuning or training Franceschelli and Musolesi ( 2023 ) . However, additional insight into transformational creative problem solving comes from prior work in CC, that describes creative problems as those with a poorly defined structure where a solution is not immediately apparent Olteteanu ( 2014 ) . And in such cases, “… re-representation being the process which transforms an ill-structured problem into a well-structured one with direct inference to a problem solution ” Olteteanu ( 2014 ) , p.1. The notion of “re-representing” or “redefining” the problem can be best captured in the input prompts provided to an LLVM. This most closely connects to prompt engineering and in-context learning (ICL).

Prompt engineering augments LLVMs with task specific hints, called prompts, to adapt the LLVM to new tasks Gu et al. ( 2023 ) . Relatedly, in-context learning is a prompting method that provides the LLVM with instructions for solving a new task without requiring additional training. Prior work has shown that in-context learning and gradient-based optimization are equivalent Von Oswald et al. ( 2023 ) , thus connecting ICL to training or fine-tuning.

Extension of transformational creativity to LLVMs: Task re-representations for creative problem solving, through prompting or ICL, has not been well explored within ML. Prompt engineering and ICL is a challenging task, since model performance depends strongly on the chosen prompts Rubin et al. ( 2021 ) , further compounded by the fact that creative problems are inherently poorly defined Olteteanu ( 2014 ) . However, useful insights can be derived from CC literature. For instance, regarding problems that require creatively re-purposing objects, the Object-replacement-object-composition (OROC) framework Olteţeanu and Falomir ( 2016 ) illustrates re-representations of tasks, that can be translated into prompts. The paper defines three different types of creative tasks involving objects, and their task re-representations as (from Olteţeanu and Falomir ( 2016 ) , p.16):

Replace an unfound object needed for a task with other objects present in the environment: “If I do not have an object X, which I would normally use because of its affordance 1 1 1 Affordance is defined as the relation between an agent, action and object, e.g., bowls have the “contain” affordance for humans. A ⁢ f X 𝐴 subscript 𝑓 𝑋 Af_{X} italic_A italic_f start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT , what other object Y could I use, so that I can get a similar affordance, A ⁢ f X ≈ A ⁢ f Y 𝐴 subscript 𝑓 𝑋 𝐴 subscript 𝑓 𝑌 Af_{X}\approx Af_{Y} italic_A italic_f start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT ≈ italic_A italic_f start_POSTSUBSCRIPT italic_Y end_POSTSUBSCRIPT ? ”

𝐴 subscript 𝑓 𝑌 1 𝐴 subscript 𝑓 𝑌 2 … 𝐴 subscript 𝑓 𝑌 𝑛 Af_{X}\approx Af_{X^{\prime}},Af_{X}\approx Af_{Y1}+Af_{Y2}+...+Af_{Yn} italic_A italic_f start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT ≈ italic_A italic_f start_POSTSUBSCRIPT italic_X start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT end_POSTSUBSCRIPT , italic_A italic_f start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT ≈ italic_A italic_f start_POSTSUBSCRIPT italic_Y 1 end_POSTSUBSCRIPT + italic_A italic_f start_POSTSUBSCRIPT italic_Y 2 end_POSTSUBSCRIPT + … + italic_A italic_f start_POSTSUBSCRIPT italic_Y italic_n end_POSTSUBSCRIPT ? ”

• subscript 𝑌 1 subscript 𝑌 2 … subscript 𝑌 𝑛 Y_{1};Y_{2};...;Y_{n} italic_Y start_POSTSUBSCRIPT 1 end_POSTSUBSCRIPT ; italic_Y start_POSTSUBSCRIPT 2 end_POSTSUBSCRIPT ; … ; italic_Y start_POSTSUBSCRIPT italic_n end_POSTSUBSCRIPT which are components of object Y 𝑌 Y italic_Y could I use to obtain an object Y i ′ subscript superscript 𝑌 ′ 𝑖 Y^{\prime}_{i} italic_Y start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT start_POSTSUBSCRIPT italic_i end_POSTSUBSCRIPT with an equivalent or similar affordance, A ⁢ f X ≈ A ⁢ f Y ′ ⁢ i 𝐴 subscript 𝑓 𝑋 𝐴 subscript 𝑓 superscript 𝑌 ′ 𝑖 Af_{X}\approx Af_{Y^{\prime}i} italic_A italic_f start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT ≈ italic_A italic_f start_POSTSUBSCRIPT italic_Y start_POSTSUPERSCRIPT ′ end_POSTSUPERSCRIPT italic_i end_POSTSUBSCRIPT ? ”

For task re-representation, affordances can refer to object properties that are relevant to the task, e.g., in some cases the shape may be relevant and in other cases, the material Olteţeanu and Falomir ( 2016 ) . Within LLVMs, the affordances A ⁢ f X 𝐴 subscript 𝑓 𝑋 Af_{X} italic_A italic_f start_POSTSUBSCRIPT italic_X end_POSTSUBSCRIPT or A ⁢ f Y 𝐴 subscript 𝑓 𝑌 Af_{Y} italic_A italic_f start_POSTSUBSCRIPT italic_Y end_POSTSUBSCRIPT can be defined via natural language, or other modalities such as images. In the following section, we present preliminary experiments on using LLVMs for object replacement, with prompts that are inspired by the above task re-representations. However, an in-depth application of these re-representations as defined in CC to in-context learning in LLVMs remains unexplored.

4.1.4 Summary

In the previous sections, we drew parallels between Boden’s three forms of creativity and approaches in LLVMs, further emphasizing how principles from CC can potentially help enable creative problem solving skills in these models.

Integration with task planning: Given the three methods, we see that transformational and combinational approaches may be especially aligned with LLVMs for high-level task planning. In contrast, exploratory methods may be suited to low-level planning, e.g., trajectory generation.

Creative problem solving as a combination of the three methods: An effective approach to creative problem solving may require all the three methods described in this section. While papers have explored chaining of LLMs within frameworks (often via prompts) Karpas et al. ( 2022 ); Ling et al. ( 2023 ) , the individual LLMs themselves do not exhibit the characteristics described here. Existing frameworks in CC have shown that achieving creative problem solving would take a combination of all three methods, each of which is triggered in different contexts Olteteanu ( 2014 ) . This presents potential opportunities for ML approaches that develop frameworks using multiple LLVMs, e.g., extending CC frameworks such as “ CreaCogs ” Olteţeanu and Falomir ( 2016 ) can be highly beneficial for productive developments in ML.

4.2 What information should LLVM embeddings be augemented with?

In the previous section, we discussed three methods for augmenting LLVM embedding spaces. In this section, we explore the question: “What information should be targeted by the three methods when augmenting the embedding space for creative problem solving?”. In the previous section, we discussed this in the context of OROC. According to the OROC framework Olteţeanu and Falomir ( 2016 ) , information about object affordances could enable models to re-represent the task, such that the solution becomes evident. We propose a small experiment to validate whether the principles of transformational creativity from OROC are useful to LLVMs. We note that creativity can occur in various contexts, e.g., creatively solving a math problem or creatively playing a chess move, each of which would require different information. However, to facilitate the discussion in this paper, we focus our scope on tasks that require innovatively replacing missing objects (OROC Task #1).

Note on embeddings vs. concepts: Our work connects “conceptual spaces” (or “concepts”) as defined in Computational Creativity literature, to “embedding spaces” (or “embeddings”) as defined in typical LM literature. We use “concepts” and “embeddings” interchangeably in this context. We make this connection to note that existing methods in Computational Creativity that operate on conceptual spaces translate to ML algorithms that operate on the LM’s embedding space. In this section, we connect the concept of “affordances” to the “embeddings” of the LLVMs in our experiments. Our goal is to show how the model can be prompted via an approach inspired by transformational creativity, to connect affordances of two seemingly distinct objects, e.g., a bowl and a spoon that appear distinct, but share the containability affordance.

4.2.1 Experiment Setup

We create a simple experiment setup that tests the “object replacement” principle from OROC, where we create test sets composed of images of objects for replacing one of five core objects: “Scoop”, “Hammer”, “Spatula”, “Toothpick”, and “Pliers”. We create two groups of tests: a) a nominal group where the actual object itself is available in each test set and requires no replacement (which serves as a form of baseline), and b) an object replacement group, where the nominal tool is missing and a creative replacement object should be chosen.

For each group, we create test sets with 4 objects each, chosen from a set of RGB images of 16 objects (Appendix Figure 3 ). We create 10 such test sets per core object (total 50 samples per model). Each test set only includes one ground truth object, along with three other random objects that will not suit as an appropriate replacement. In the nominal group, the ground truth is the actual object itself. In the object replacement group, the replacements are chosen based on self-assessment of the authors as (core object → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW replacement): “Scoop” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Bowl”; “Hammer” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Saucepan”; “Spatula” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Knife”; “Toothpick” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Safety pin”; “Pliers” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Scissors”. For each test case, we pass the images in the test set along with a prompt. We record whether the ground truth object image was chosen by the model for the prompt (i.e., assigned highest output probability) 2 2 2 CLIP generates probabilities that given images correspond to a text. ViLT and LLaVA respond with a text, and we evaluate if the model responded “yes” with a high probability for the ground truth. .

The nominal group is subjected to one type of prompt: “ Can this object be used as a ⟨ c o r e _ o b j e c t ⟩ ? \bigl{\langle}core\_object\bigl{\rangle}? ⟨ italic_c italic_o italic_r italic_e _ italic_o italic_b italic_j italic_e italic_c italic_t ⟩ ? ”. In the object replacement group, each test case is subjected to four types of prompts:

Baseline (regular) prompt: Same prompt as used in the nominal cases to obtain a baseline.

Prompt prepended with affordance information: the prompt includes additional information about the desired object affordances specified as object features.

Prompt prepended with task information: the prompt includes additional information about the desired task.

Prompt prepended with task and affordance information: the prompt includes additional information on the task and object affordance.

Case #2 aligns with task re-representations of OROC, and we explore cases #3 and #4 for comparison. We formulate our affordance prompts as brief versions of OROC’s task re-representations. According to Olteţeanu and Falomir ( 2016 ) affordances can be defined using shape features, which we apply to the prompts here. The full set of prompts is shown in Appendix Table 2 . The models that we explore include versions of CLIP Radford et al. ( 2021 ) , LLaVA Liu et al. ( 2024 ) , and ViLT Kim et al. ( 2021 ) obtained from HuggingFace. We use different model sizes ( B ase, L arge, H uge) and patch sizes (14, 16, 32). The open-source code for reproducing our experiment results (including our dataset and test cases) is available at: https://github.com/lnairGT/creative-problem-solving-LLMs . Appendix C includes more details on the experiments.

4.2.2 Results

In Table 1 , we see the performances of the different models in the nominal test group, where the object requires no creative replacement. The models perform > 90 % absent percent 90 >90\% > 90 % in such cases (except for ViLT). In Figure 2 , we see the performances (accuracy shown on a 0.0 − 1.0 0.0 1.0 0.0-1.0 0.0 - 1.0 scale) of the models in the object replacement test cases, where the object requires a creative replacement. For reference, a model that randomly picks an object achieves about 30% overall accuracy. Figure 2 shows average accuracies for the different prompting strategies across random test sets. From Table 1 to Figure 2 (“regular”), the models perform poorly when they need to creatively reason about object replacements, highlighting their limitation. Comparing the “Regular” tab in Figure 2 to “Affordance”, we see a general improvement in model performances, when object affordance information is provided , consistent with description of the OROC framework Olteţeanu and Falomir ( 2016 ) . However, information about the task (Figure 2 , “Task” ) leads to mostly detrimental results. Information about task and affordances (Figure 2 , “Task + Affordance”) does not lead to substantial improvements either, and is also detrimental in certain cases. We note that there is quite a variance in performances across the different models, which may be partially attributed to the original training datasets of the models. These observations warrant further exploration beyond the scope of this paper. Appendix D includes a detailed, class-wise breakdown of the results.

4.2.3 Summary

While the experiments that we conducted are only preliminary, they offer some validity that the extension of principles in Computational Creativity can help overcome limitations of LLVMs in creative problem solving. The notion of task re-representation via improved prompting warrants further investigation in LLVMs, with regards to how the prompts can be generated automatically based on the creative task.

The models used in our experiments have all been trained jointly in visual and text domains. Multi-modal prompting capabilities may be useful for achieving creative problem solving. It can be quite challenging to describe affordances in words (example of “hammers” in our tests) and they may be better described through other means, e.g., images or depth maps or spectral data for material properties Erickson et al. ( 2020 ) . This would require application of multi-modal LLVMs that can process a variety of data types Girdhar et al. ( 2023 ); Han et al. ( 2023 ) . Computational creativity can offer insights into meaningful representations of these different modalities that would help achieve creative problem solving, e.g., whether object material or shape matters more for one task vs. another Olteţeanu and Falomir ( 2016 ) .

It is also worth noting that the creative problem solving examples in our experiments are human-centric. For instance, robots may not have similar capabilities as humans to manipulate bowls for scooping. In such cases, LLVMs need to account for the affordances as described with respect to the agent , in order to derive creative solutions. However, that adds another level of complexity, yet to be explored, since these models are typically trained on human-centric data.

5 Evaluation of Creativity

An important discussion in the context of creative problem solving is, how can creative problem solving be evaluated? . Prior work has proposed that creativity necessitates both novelty and value Boden ( 1998 ); Runco and Jaeger ( 2012 ) , where the former guarantees that the generated outputs of a creative process are original, and the latter ensures that the generated outputs are useful. In the context of CPS, novelty refers to the discovery of new concepts (as defined in section 3.1 ), whereas value insists that the newly discovered concepts successfully solve the task. Hence, benchmarks for CPS should specifically evaluate how the task was solved (novelty and value) rather than the typical ML evaluation of whether the task was successful or not (value only). Some existing approaches that make this distinction describe problem settings that can be used to measure CPS skills of LLMs through the implicit integration of novelty and value measurements Tian et al. ( 2023 ); Naeini et al. ( 2023 ); Bisk et al. ( 2020 ); Talmor et al. ( 2022 ) . In Tian et al. ( 2023 ) , the authors create a dataset of 1600 real-world problems that necessarily involve creative reasoning abilities. Their proposed benchmark involves identifying novel approaches that can accomplish the given task (value). Similarly, in Naeini et al. ( 2023 ) , the authors introduce the Only-Connect-Wall (OCW) dataset to measure CPS capabilities of LLMs. The authors in Bisk et al. ( 2020 ) explore physical commonsense reasoning that is more generally applicable, beyond object-based creative problems. The authors introduce Physical Interaction: Question Answering, or PIQA consisting of 16,000 QA pairs where each question is paired with two possible common-sense solutions with a ground truth. In Talmor et al. ( 2022 ) , the authors introduce CommonSenseQA 2.0 (CSQA2) dataset consisting of both object-based and non-object based creative problems. The dataset consists of 14,343 questions distributed across 1,868 distinct topics. Currently, to the best of our knowledge, there are no standard benchmarks available to measure CPS skills of VLMs, although our preliminary experiments show one way to measure this using the task of object substitution.

6 Conclusion and Future Work

In this paper, we argued that an effective approach for enabling creative problem solving – currently a key limitation of LLVMs – should derive from Computational Creativity literature. To emphasize this at each juncture, we discussed the specific principles from CC that can be extended to achieve creative problem solving in LLVMs, describing the potential for further research with these insights. It is rare to see special tracks or workshops targeted at Computational Creativity within more prestigious ML conferences. These programs typically focus on creative artifact generation and art (such as the NeurIPS Workshop on Machine Learning for Creativity and Design NeurIPS ( 2022 ) or the recent tutorial at EMNLP on Creative Natural Language Generation Chakrabarty et al. ( 2023 ) ), but do not discuss CPS, thus failing to bridge the gap between CC and ML. We hope to see a deeper integration of the CC communities at such strong ML venues. We hope to encourage the reader to view creative problem solving and ML holistically, through the lens of Computational Creativity.

7 Limitations

Literature outside of Computational Creativity that enables CPS is unexplored: Our paper predominantly focuses on CC literature. This work does not cover literature beyond CC that can potentially inform creative problem solving in LLVMs. Although CC literature broadly encompasses psychology, neuroscience and philosophy, our future work seeks to explore specific literature within these sub-domains and discuss their applicability to creative problem solving and ML.

Lack of an explicit creative problem solving algorithm for LLVMs: Since the scope of our work aligns with a position paper, we have not focused on developing a concrete algorithm for creative problem solving in LLVMs. The prompting strategies explored in our preliminary experiments are manually specified, and our work does not elaborate on how these prompts may be automatically discovered. While our paper seeks to address some of the key gaps that prevent the application of CC literature to ML, there are still several unanswered questions when it comes to the practical implementation of an ML approach: e.g., what is a good representation for concepts that facilitate creative problem solving (symbolic, non-symbolic, or hybrid)? What is a good problem formulation for a given creative problem solving task (planning or learning)? etc. However, these questions are not directly answered within the scope of our work.

8 Ethical Considerations

The authors do not have specific ethical considerations to be highlighted with respect to this work.

• Alayrac et al. (2022) Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, Iain Barr, Yana Hasson, Karel Lenc, Arthur Mensch, Katherine Millican, Malcolm Reynolds, et al. 2022. Flamingo: a visual language model for few-shot learning. Advances in Neural Information Processing Systems , 35:23716–23736.
• Anna Tong and Hu (2023) Jeffrey Dastin Anna Tong and Krystal Hu. 2023. Openai researchers warned board of ai breakthrough ahead of ceo ouster, sources say. https://www.reuters.com/technology/sam-altmans-ouster-openai-was-precipitated-by-letter-board-about-ai-breakthrough-2023-11-22/. [Online; accessed 19-Jan-2024].
• Atkeson et al. (2018) Christopher G Atkeson, PW Babu Benzun, Nandan Banerjee, Dmitry Berenson, Christoper P Bove, Xiongyi Cui, Mathew DeDonato, Ruixiang Du, Siyuan Feng, Perry Franklin, et al. 2018. What happened at the darpa robotics challenge finals. The DARPA robotics challenge finals: Humanoid robots to the rescue , pages 667–684.
• Bansal et al. (2024) Rachit Bansal, Bidisha Samanta, Siddharth Dalmia, Nitish Gupta, Shikhar Vashishth, Sriram Ganapathy, Abhishek Bapna, Prateek Jain, and Partha Talukdar. 2024. Llm augmented llms: Expanding capabilities through composition. arXiv preprint arXiv:2401.02412 .
• BBC (2012) BBC. 2012. Us navy funds ’macgyver’ robot that can create tools. https://www.bbc.com/news/technology-19902954 . [Online; accessed 9-April-2024].
• Bisk et al. (2020) Yonatan Bisk, Rowan Zellers, Jianfeng Gao, Yejin Choi, et al. 2020. Piqa: Reasoning about physical commonsense in natural language. In Proceedings of the AAAI conference on artificial intelligence , volume 34, pages 7432–7439.
• Boden (1998) Margaret A. Boden. 1998. Creativity and Artificial Intelligence. Artificial Intelligence , 1-2:347–356.
• Boden (2005) Margaret A. Boden. 2005. What is creativity? Creativity in human evolution and prehistory .
• Bubeck et al. (2023) Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, et al. 2023. Sparks of artificial general intelligence: Early experiments with gpt-4. arXiv preprint arXiv:2303.12712 .
• Cass (2005) Stephen Cass. 2005. Apollo 13, we have a solution. IEEE Spectrum On-line, 04 , 1.
• Chakrabarty et al. (2023) Tuhin Chakrabarty, Vishakh Padmakumar, He He, and Nanyun Peng. 2023. Creative natural language generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing: Tutorial Abstracts , pages 34–40.
• Chen et al. (2023) Lili Chen, Shikhar Bahl, and Deepak Pathak. 2023. Playfusion: Skill acquisition via diffusion from language-annotated play. In Conference on Robot Learning , pages 2012–2029. PMLR.
• Chen et al. (2018) Liuqing Chen, Pan Wang, Feng Shi, Ji Han, Peter Childs, et al. 2018. A computational approach for combinational creativity in design. In DS 92: Proceedings of the DESIGN 2018 15th International Design Conference , pages 1815–1824.
• Copet et al. (2023) Jade Copet, Felix Kreuk, Itai Gat, Tal Remez, David Kant, Gabriel Synnaeve, Yossi Adi, and Alexandre Défossez. 2023. Simple and controllable music generation. arXiv preprint arXiv:2306.05284 .
• DeCaro et al. (2011) Marci S DeCaro, Robin D Thomas, Neil B Albert, and Sian L Beilock. 2011. Choking under pressure: multiple routes to skill failure. Journal of experimental psychology: general , 140(3):390.
• Du et al. (2023) Yuqing Du, Olivia Watkins, Zihan Wang, Cédric Colas, Trevor Darrell, Pieter Abbeel, Abhishek Gupta, and Jacob Andreas. 2023. Guiding pretraining in reinforcement learning with large language models. arXiv preprint arXiv:2302.06692 .
• Erickson et al. (2020) Zackory Erickson, Eliot Xing, Bharat Srirangam, Sonia Chernova, and Charles C Kemp. 2020. Multimodal material classification for robots using spectroscopy and high resolution texture imaging. In 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) , pages 10452–10459. IEEE.
• Fauconnier and Turner (2003) Gilles Fauconnier and Mark Turner. 2003. Conceptual blending, form and meaning. Recherches en communication , 19:57–86.
• Fei et al. (2022) Nanyi Fei, Zhiwu Lu, Yizhao Gao, Guoxing Yang, Yuqi Huo, Jingyuan Wen, Haoyu Lu, Ruihua Song, Xin Gao, Tao Xiang, et al. 2022. Towards artificial general intelligence via a multimodal foundation model. Nature Communications , 13(1):3094.
• Feng et al. (2023) Xidong Feng, Ziyu Wan, Muning Wen, Ying Wen, Weinan Zhang, and Jun Wang. 2023. Alphazero-like tree-search can guide large language model decoding and training. arXiv preprint arXiv:2309.17179 .
• Franceschelli and Musolesi (2023) Giorgio Franceschelli and Mirco Musolesi. 2023. On the creativity of large language models. arXiv preprint arXiv:2304.00008 .
• Gilhooly (2016) Kenneth J Gilhooly. 2016. Incubation and intuition in creative problem solving. Frontiers in psychology , 7:1076.
• Girdhar et al. (2023) Rohit Girdhar, Alaaeldin El-Nouby, Zhuang Liu, Mannat Singh, Kalyan Vasudev Alwala, Armand Joulin, and Ishan Misra. 2023. Imagebind: One embedding space to bind them all .
• Gizzi et al. (2022) Evana Gizzi, Lakshmi Nair, Sonia Chernova, and Jivko Sinapov. 2022. Creative problem solving in artificially intelligent agents: A survey and framework. Journal of Artificial Intelligence Research , 75:857–911.
• Goertzel (2014) Ben Goertzel. 2014. Artificial general intelligence: concept, state of the art, and future prospects. Journal of Artificial General Intelligence , 5(1):1.
• Golovneva et al. (2023) O. Golovneva, S. O’Brien, R. Pasunuru, T. Wang, L. Zettlemoyer, M. Fazel-Zarandi, and A. Celikyilmaz. 2023. Pathfinder: Guided search over multi-step reasoning paths. arXiv preprint arXiv:2312.05180 .
• Grudin and Jacques (2019) Jonathan Grudin and Richard Jacques. 2019. Chatbots, humbots, and the quest for artificial general intelligence. In Proceedings of the 2019 CHI conference on human factors in computing systems , pages 1–11.
• Gu et al. (2023) Jindong Gu, Zhen Han, Shuo Chen, Ahmad Beirami, Bailan He, Gengyuan Zhang, Ruotong Liao, Yao Qin, Volker Tresp, and Philip Torr. 2023. A systematic survey of prompt engineering on vision-language foundation models. arXiv preprint arXiv:2307.12980 .
• Guan et al. (2023) Lin Guan, Karthik Valmeekam, Sarath Sreedharan, and Subbarao Kambhampati. 2023. Leveraging pre-trained large language models to construct and utilize world models for model-based task planning. arXiv preprint arXiv:2305.14909 .
• Guilford (1967) Joy P Guilford. 1967. Creativity: Yesterday, today and tomorrow. The Journal of Creative Behavior , 1(1):3–14.
• Hammond et al. (2013) Adam Hammond, Julian Brooke, and Graeme Hirst. 2013. A tale of two cultures: Bringing literary analysis and computational linguistics together. In Proceedings of the Workshop on Computational Linguistics for Literature , pages 1–8.
• Han et al. (2023) Jiaming Han, Kaixiong Gong, Yiyuan Zhang, Jiaqi Wang, Kaipeng Zhang, Dahua Lin, Yu Qiao, Peng Gao, and Xiangyu Yue. 2023. Onellm: One framework to align all modalities with language .
• Hélie and Sun (2010) Sebastien Hélie and Ron Sun. 2010. Incubation, insight, and creative problem solving: a unified theory and a connectionist model. Psychological review , 117(3):994.
• Huang et al. (2022) Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. 2022. Language models as zero-shot planners: Extracting actionable knowledge for embodied agents. In International Conference on Machine Learning , pages 9118–9147. PMLR.
• Ilharco et al. (2022) Gabriel Ilharco, Marco Tulio Ribeiro, Mitchell Wortsman, Suchin Gururangan, Ludwig Schmidt, Hannaneh Hajishirzi, and Ali Farhadi. 2022. Editing models with task arithmetic. arXiv preprint arXiv:2212.04089 .
• Karpas et al. (2022) Ehud Karpas, Omri Abend, Yonatan Belinkov, Barak Lenz, Opher Lieber, Nir Ratner, Yoav Shoham, Hofit Bata, Yoav Levine, Kevin Leyton-Brown, Dor Muhlgay, Noam Rozen, Erez Schwartz, Gal Shachaf, Shai Shalev-Shwartz, Amnon Shashua, and Moshe Tenenholtz. 2022. Mrkl systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning .
• Kim et al. (2021) Wonjae Kim, Bokyung Son, and Ildoo Kim. 2021. Vilt: Vision-and-language transformer without convolution or region supervision. In International Conference on Machine Learning , pages 5583–5594. PMLR.
• Lahikainen et al. (2024) Joonas Lahikainen, Nadia M Ady, and Christian Guckelsberger. 2024. Creativity and markov decision processes. arXiv preprint arXiv:2405.14966 .
• Li et al. (2023) Boyi Li, Philipp Wu, Pieter Abbeel, and Jitendra Malik. 2023. Interactive task planning with language models. arXiv preprint arXiv:2310.10645 .
• Liang et al. (2023) Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. 2023. Code as policies: Language model programs for embodied control. In 2023 IEEE International Conference on Robotics and Automation (ICRA) , pages 9493–9500. IEEE.
• Ling et al. (2023) Zhan Ling, Yunhao Fang, Xuanlin Li, Tongzhou Mu, Mingu Lee, Reza Pourreza, Roland Memisevic, and Hao Su. 2023. Unleashing the creative mind: Language model as hierarchical policy for improved exploration on challenging problem solving .
• Liu et al. (2024) Haotian Liu, Chunyuan Li, Qingyang Wu, and Yong Jae Lee. 2024. Visual instruction tuning. Advances in neural information processing systems , 36.
• Ma et al. (2023) Yuxi Ma, Chi Zhang, and Song-Chun Zhu. 2023. Brain in a vat: On missing pieces towards artificial general intelligence in large language models. arXiv preprint arXiv:2307.03762 .
• Matena and Raffel (2022) Michael S Matena and Colin A Raffel. 2022. Merging models with fisher-weighted averaging. Advances in Neural Information Processing Systems , 35:17703–17716.
• Moor et al. (2023) Michael Moor, Oishi Banerjee, Zahra Shakeri Hossein Abad, Harlan M Krumholz, Jure Leskovec, Eric J Topol, and Pranav Rajpurkar. 2023. Foundation models for generalist medical artificial intelligence. Nature , 616(7956):259–265.
• Moruzzi (2020) Caterina Moruzzi. 2020. Artificial creativity and general intelligence. Journal of Science and Technology of the Arts .
• Naeini et al. (2023) Saeid Naeini, Raeid Saqur, Mozhgan Saeidi, John Giorgi, and Babak Taati. 2023. Large language models are fixated by red herrings: Exploring creative problem solving and einstellung effect using the only connect wall dataset. arXiv preprint arXiv:2306.11167 .
• NeurIPS (2022) NeurIPS. 2022. Workshop on machine learning for creativity and design. https://nips.cc/virtual/2022/workshop/49965. [Online; accessed 19-Jan-2024].
• Olteteanu (2014) Ana-Maria Olteteanu. 2014. Two general classes in creative problem-solving? an account based on the cognitive processess involved in the problem structure-representation structure relationship. Publications of the Institute of Cognitive Science .
• Olteţeanu and Falomir (2016) Ana-Maria Olteţeanu and Zoe Falomir. 2016. Object replacement and object composition in a creative cognitive system. towards a computational solver of the alternative uses test. Cognitive Systems Research , 39:15–32.
• Patel (2023) Dwarkesh Patel. 2023. Llms need search for problem solving - shane legg (deepmind founder). https://www.youtube.com/watch?v=qulfo6-54k0. [Online; accessed 19-Jan-2024].
• Pennachin and Goertzel (2007) Cassio Pennachin and Ben Goertzel. 2007. Contemporary approaches to artificial general intelligence. In Artificial general intelligence , pages 1–30. Springer.
• Prasad et al. (2023) Archiki Prasad, Alexander Koller, Mareike Hartmann, Peter Clark, Ashish Sabharwal, Mohit Bansal, and Tushar Khot. 2023. Adapt: As-needed decomposition and planning with language models. arXiv preprint arXiv:2311.05772 .
• Radford et al. (2021) Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. 2021. Learning transferable visual models from natural language supervision. In International conference on machine learning , pages 8748–8763. PMLR.
• Rombach et al. (2021) Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. 2021. High-resolution image synthesis with latent diffusion models. 2022 ieee. In CVF Conference on Computer Vision and Pattern Recognition (CVPR) , pages 10674–10685.
• Rubin et al. (2021) Ohad Rubin, Jonathan Herzig, and Jonathan Berant. 2021. Learning to retrieve prompts for in-context learning. arXiv preprint arXiv:2112.08633 .
• Runco and Jaeger (2012) Mark A Runco and Garrett J Jaeger. 2012. The standard definition of creativity. Creativity research journal , 24(1):92–96.
• Sarathy and Scheutz (2018) Vasanth Sarathy and Matthias Scheutz. 2018. Macgyver problems: Ai challenges for testing resourcefulness and creativity. Advances in Cognitive Systems , 6:31–44.
• Shevlin et al. (2019) Henry Shevlin, Karina Vold, Matthew Crosby, and Marta Halina. 2019. The limits of machine intelligence: Despite progress in machine intelligence, artificial general intelligence is still a major challenge. EMBO reports , 20(10):e49177.
• Shukla et al. (2023) Yash Shukla, Wenchang Gao, Vasanth Sarathy, Alvaro Velasquez, Robert Wright, and Jivko Sinapov. 2023. Lgts: Dynamic task sampling using llm-generated sub-goals for reinforcement learning agents. arXiv preprint arXiv:2310.09454 .
• Silver et al. (2023) Tom Silver, Soham Dan, Kavitha Srinivas, Joshua B Tenenbaum, Leslie Pack Kaelbling, and Michael Katz. 2023. Generalized planning in pddl domains with pretrained large language models. arXiv preprint arXiv:2305.11014 .
• Skreta et al. (2024) Marta Skreta, Zihan Zhou, Jia Lin Yuan, Kourosh Darvish, Alán Aspuru-Guzik, and Animesh Garg. 2024. Replan: Robotic replanning with perception and language models. arXiv preprint arXiv:2401.04157 .
• Talmor et al. (2022) Alon Talmor, Ori Yoran, Ronan Le Bras, Chandra Bhagavatula, Yoav Goldberg, Yejin Choi, and Jonathan Berant. 2022. Commonsenseqa 2.0: Exposing the limits of ai through gamification. arXiv preprint arXiv:2201.05320 .
• Tennenholtz et al. (2023) Guy Tennenholtz, Yinlam Chow, Chih-Wei Hsu, Jihwan Jeong, Lior Shani, Azamat Tulepbergenov, Deepak Ramachandran, Martin Mladenov, and Craig Boutilier. 2023. Demystifying embedding spaces using large language models. arXiv preprint arXiv:2310.04475 .
• Tian et al. (2023) Yufei Tian, Abhilasha Ravichander, Lianhui Qin, Ronan Le Bras, Raja Marjieh, Nanyun Peng, Yejin Choi, Thomas L Griffiths, and Faeze Brahman. 2023. Macgyver: Are large language models creative problem solvers? arXiv preprint arXiv:2311.09682 .
• Turner et al. (2020) MC Turner, LV Duggan, BA Glezerson, and SD Marshall. 2020. Thinking outside the (acrylic) box: a framework for the local use of custom-made medical devices. Anaesthesia .
• Van Heerden and Bas (2021) Imke Van Heerden and Anil Bas. 2021. Ai as author–bridging the gap between machine learning and literary theory. Journal of Artificial Intelligence Research , 71:175–189.
• Vaswani et al. (2017) Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. Advances in neural information processing systems , 30.
• Ventura (2014) Dan Ventura. 2014. Can a computer be lucky? and other ridiculous questions posed by computational creativity. In Artificial General Intelligence: 7th International Conference, AGI 2014, Quebec City, QC, Canada, August 1-4, 2014. Proceedings 7 , pages 208–217. Springer.
• Von Oswald et al. (2023) Johannes Von Oswald, Eyvind Niklasson, Ettore Randazzo, João Sacramento, Alexander Mordvintsev, Andrey Zhmoginov, and Max Vladymyrov. 2023. Transformers learn in-context by gradient descent. In International Conference on Machine Learning , pages 35151–35174. PMLR.
• Wallas (1926) Graham Wallas. 1926. The art of thought . 24. Harcourt, Brace.
• Wang (2023) Brian Wang. 2023. Openai q* could be based upon a* search without expansions. https://www.nextbigfuture.com/2023/11/openai-q-could-be-based-upon-a-search-without-expansions.html. [Online; accessed 19-Jan-2024].
• Wiggins (2006) Geraint A Wiggins. 2006. A preliminary framework for description, analysis and comparison of creative systems. Knowledge-based systems , 19(7):449–458.
• Xi et al. (2023) Zhiheng Xi, Wenxiang Chen, Xin Guo, Wei He, Yiwen Ding, Boyang Hong, Ming Zhang, Junzhe Wang, Senjie Jin, Enyu Zhou, et al. 2023. The rise and potential of large language model based agents: A survey. arXiv preprint arXiv:2309.07864 .
• Yao et al. (2023) Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L Griffiths, Yuan Cao, and Karthik Narasimhan. 2023. Tree of thoughts: Deliberate problem solving with large language models. arXiv preprint arXiv:2305.10601 .
• Zhang et al. (2023a) Danyang Zhang, Lu Chen, Situo Zhang, Hongshen Xu, Zihan Zhao, and Kai Yu. 2023a. Large language model is semi-parametric reinforcement learning agent. arXiv preprint arXiv:2306.07929 .
• Zhang et al. (2023b) Shun Zhang, Zhenfang Chen, Yikang Shen, Mingyu Ding, Joshua B Tenenbaum, and Chuang Gan. 2023b. Planning with large language models for code generation. arXiv preprint arXiv:2303.05510 .
• Zhou et al. (2023) Andy Zhou, Kai Yan, Michal Shlapentokh-Rothman, Haohan Wang, and Yu-Xiong Wang. 2023. Language agent tree search unifies reasoning acting and planning in language models. arXiv preprint arXiv:2310.04406 .

Appendix A Alternate Definitions of Creative Problem Solving

Prior work by Olteţeanu Olteteanu ( 2014 ) defines CPS from an object affordance perspective, where affordances broadly refer to action possibilities for objects, e.g., cups are pour-able and doors are open-able. The authors in Olteteanu ( 2014 ) define creative problems as nominal problem solving tasks that have a poor representational structure, and as “ the ability of a cognitive, natural, or artificial system to use new objects to solve a problem, other than the ones that have been stored in its memory as tools for that specific purpose (if any), or to create those objects by putting together objects or parts of objects the system has access to. Depending on the problem, objects can be either physical or abstract/informational (concepts, problem templates, heuristics or other forms of representations) ”. However, this definition is primarily object-creativity centered, and does not cover a wider range of creative problems.

Follow-up work by Sarathy and Scheutz Sarathy and Scheutz ( 2018 ) , define “ Macgyver-esque ” creativity as a planning task that involves “ generating, executing, and learning strategies for identifying and solving seemingly unsolvable real-world problems ”. They introduce the “ MacGyver Problem ” (MGP) as a planning problem with an unreachable goal state. Through the modification of the agent’s domain knowledge (through domain expansion and domain contraction ), the agent must discover new information and incorporate it into its existing domain knowledge, allowing the agent to accomplish the task. The domain expansion and contraction processes align with the divergent-convergent model of creative problem solving Guilford ( 1967 ) . The definition of an MGP aligns well with the formulation of planning problems in ML, but less with learning or hybrid planning-learning approaches.

Appendix B Alternate theories on creative problem solving and their applications to ML

While there is exhaustive literature regarding theories on general creativity, we focus specifically on creative problem solving, with three well received works: Divergent-Convergent Thinking Guilford ( 1967 ) , Explicit-Implicit Interaction Theory Hélie and Sun ( 2010 ) , and the Creative Systems Framework Wiggins ( 2006 ) . We discuss their applicability to ML in addition to the literature discussed in the main body of this paper. Our goal in this section is to further widen the discussion on integrating CC and ML to achieve creative problem solving in LLVMs, with additional literature.

B.0.1 Divergent-Convergent Thinking

In Guilford ( 1967 ) , the authors discuss the notion of “divergent-convergent” thinking. Divergent thinking or “divergent-production” (DP) abilities involve a more open-ended generation of a variety of ideas, whereas convergent thinking focuses on applying specific ideas to solve the problem.

Applicability to CPS in LLVMs: Prior work by Tian et al. ( 2023 ) have demonstrated the applicability of “divergent-convergent” thinking towards solving Macgyver problems. Similar in spirit to our experiments with VLMs in Section 4.2.1 , the authors prompt LLMs with descriptions of objects to enable the LLMs to reason about solving the task. Their work is, to the best of our knowledge, the only direct example demonstrating the value of CC literature in enabling CPS in LLMs.

B.0.2 Explicit-Implicit Interaction Theory

In Hélie and Sun ( 2010 ) , the authors introduce the Explicit-Implicit Interaction (EII) theory, building upon the seminal work in Wallas ( 1926 ) , that describes four stages of creativity: Preparation, incubation, illumination (i.e., insight), and verification. Preparation refers to the initial stage of searching in many different directions, which may fail to find a solution (i.e., impasse) in case of ill-defined problems (as is the case with CPS). Following an impasse, the incubation phase begins, where attention is not devoted to solving the problem. Over a period of time, illumination is the manifestation of the solution to the problem within the conscious thought (i.e., “Aha” moment). Finally, verification involves using deliberative thinking to assess if the solution indeed solves the problem.

Applicability to CPS in LLVMs: The authors in Hélie and Sun ( 2010 ) incorporate the four stages via a concrete computational method into the CLARION cognitive architecture. Prior work has also introduced a CPS framework for ML approaches inspired by the four stages Gizzi et al. ( 2022 ) . In their work, “preparation” aligns with problem formulation, either task learning or planning. Incubation and illumination aligns with knowledge representation (symbolic, non-symbolic, or hybrid), and knowledge manipulation (functions that manipulate the conceptual space). Lastly, verification aligns with evaluation (via simulation, real-world platforms, or benchmarks). Although these works do not explicitly cover LLVMs and related algorithms, they demonstrate the value of integrating CC literature in ML, and can serve as useful starting points for ML approaches towards creative problem solving in LLVMs.

B.0.3 Creative Systems Framework

In Wiggins ( 2006 ) , the author expands on Boden’s levels further in the context of a framework that formalizes creative systems. The paper defines: a) creative system, b) creative behavior, c) novelty, and d) value. The paper also discusses formalized notion of a universe of possibilities , and conceptual spaces . Crucially, the work describes the characteristics of a creative agent, that can help distinguish modes of failures within a creative system, namely: a) hopeless uninspiration – where there are no valued concepts within the universe; b) conceptual uninspiration – where there are no valued concepts within the conceptual space of the agent; and c) generative uninspiration – where an agent is unable to find a valued concept owing to the specific method (e.g., search) employed.

Applicability to CPS in LLVMs: While the discussion of novelty, value and conceptual spaces in Wiggins ( 2006 ) aligns with our descriptions in Section 4 , the different modes of uninspiration offers potential ways to assess failure modes in LLVMs. This allows agents to distinguish between systems where creative problem solving is not possible (hopeless uninspiration), as compared to systems where the conceptual space or the methodology for searching the conceptual space, may be at fault (conceptual or generative uninspiration). Although this approach has not been expanded in existing literature, it presents a promising direction for an evaluation framework that can distinguish CPS from non-CPS problems.

B.1 A potential link between creative problem solving and general intelligence

Existing literature hints at a potential link between creative problem solving and Artificial General Intelligence (AGI) - systems that are broadly capable of solving almost all tasks that humans can Shevlin et al. ( 2019 ) . For instance, in Moruzzi ( 2020 ) , p.85., the author argues that there exists a strong correlation between creativity and AGI: “ … features that systems need to develop in order to achieve general intelligence are aspects that they need to possess also to earn the attribute creative ”. In Goertzel ( 2014 ) , the author compiles a list of competencies deemed essential for achieving AGI, including creative capacities like “ conceptual invention ” and “ creative constructive play with objects ”. The processes of “insight” or “incubation” often associated with creative problem solving Hélie and Sun ( 2010 ); Gilhooly ( 2016 ) is also considered important for AGI Ventura ( 2014 ) . Taken together, it is likely that any promising vision of AGI would be incomplete without creative problem solving .

Alongside the heavy ongoing discussion of AGI surrounding LLVMs Bubeck et al. ( 2023 ); Fei et al. ( 2022 ); Ma et al. ( 2023 ); Xi et al. ( 2023 ); Moor et al. ( 2023 ); Grudin and Jacques ( 2019 ) , there is often little to no discussion of creative problem solving or Computational Creativity within mainstream ML. As described in Moruzzi ( 2020 ) , p.96, “ The investigation on the nature of creativity and on how it manifests itself not only in human but also in animal and artificial systems should, thus, not be intended as a niche discussion but, rather, as a fundamental research which can lay the foundations for further studies in artificial intelligence and its relation to humans ”. We hope that this work will encourage discussions of creative problem solving and Computational Creativity alongside discussions on AGI.

Appendix C Experiment Settings

Prompt type

Prompt

Regular

“can this object be used as a scoop?” “can this object be used as a hammer?” “can this object be used as a spatula?” “can this object be used as a toothpick?” “can this object be used as pliers?” “scoops must be concave and hollow. can this object be used as a scoop?” “hammers must be heavy and have a handle attached to a cylinder at the end. can this object be used as a hammer?” “spatulas must have a handle attached to a flat surface at the end. can this object be used as a spatula?” “toothpicks must have a pointed tip. can this object be used as a toothpick?” “pliers must have two-prongs. can this object be used as pliers?” “scoops can transfer beans from one jar to another jar. can this object be used as a scoop?” “hammers can hit a nail into the wall. can this object be used as a hammer?” “spatulas can spread butter onto a pan. can this object be used as a spatula?” “toothpicks can pick food caught between the teeth. can this object be used as a toothpick?” “pliers can grab a coin. can this object be used as pliers?” “scoops can transfer beans from one jar to another jar. scoops are concave and hollow. can this object be used as a scoop?” “hammers can hit a nail into the wall. hammers have a handle attached to a cylinder at the end. can this object be used as a hammer?” “spatulas can spread butter onto a pan. spatulas have a handle attached to a flat surface at the end. can this object be used as a spatula?” “toothpicks can pick food caught between the teeth. toothpicks have a pointed tip. can this object be used as a toothpick?” “pliers can grab a coin. pliers have two-prongs. can this object be used as pliers?” C.1 Data: Test images Figure 3 shows the test set of 16 RGB images of objects used for the object substitution task. From the shown image dataset, we create test sets with 4 objects each, chosen from the set of 16 object images. We create 10 such test sets per core object (total 50 samples per model). Each test set only includes one ground truth object, along with three other random objects that will not suit as an appropriate replacement. In the nominal group, the ground truth is the actual object itself. In the object replacement group, the replacements are chosen based on self-assessment of the authors as (core object → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW replacement): “Scoop” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Bowl”; “Hammer” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Saucepan”; “Spatula” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Knife”; “Toothpick” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Safety pin”; “Pliers” → absent → \xrightarrow{} start_ARROW start_OVERACCENT end_OVERACCENT → end_ARROW “Scissors”. C.2 Model: Checkpoints For all the models, we use pre-trained HuggingFace checkpoints, with no additional training or fine-tuning. The models are of different architecture sizes and patch sizes: “CLIP-B-32” uses the “openai/clip-vit-base-patch32” which is a base model with a patch size of 32. “CLIP-B-16” uses “openai/clip-vit-base-patch16” – a base model with patch size of 16. “CLIP-L-14” uses “openai/clip-vit-large-patch14” – a large model with patch size of 14. “CLIP-H-14” uses “laion/CLIP-ViT-H-14-laion2B-s32B-b79K” which is a “huge” model, with a patch size of 14. This model is trained with the 2 billion sample English subset of LAION-5B. For LLaVA, we use the “llava-hf/llava-1.5-7b-hf” with 7B parameters, version 1.5. Lastly, “VILT-B-32” uses “dandelin/vilt-b32-finetuned-vqa” trained for visual question answering. However, there is limited data available on HuggingFace regarding the model. C.3 Prompts used in testing In this section, we discuss the prompts used in the different testing conditions (see Table 2 ). We explore four classes of prompts for the creative object substitution task: “Regular”, “Affordance”, “Task” and “Task and affordance”. Regular prompts involve a direct prompt as to whether a given object will suffice as a substitute for the missing object. Affordance prompts, adds information about the desired affordances that are essential for replacing the missing object. Task prompts adds additional information on the task to be performed as context for whether a given object can be used as replacement for the missing object. Lastly, task and affordance prompts combine the task and object affordance information within the prompt. C.4 Testing Procedure For each test case, we pass the images in the test set along with a prompt belonging to one of the four classes described in Table 2 . We record whether the ground truth object image was chosen by the model for the prompt (i.e., assigned highest output probability). CLIP generates probabilities that given images correspond to a text. ViLT responds with a text, and we evaluate if the model responded “yes” with a high probability for the ground truth. C.5 Testing Infrastructure We used NVIDIA-A100 GPUs to run the evaluation. However, the models are not too large and we have tested and confirmed that the code can be executed on CPU only as well. Appendix D Continued Experiment Results In this section, we show the class-wise breakdown of the different models for the different prompting strategies (Figures 4 - 7 ). We note that “hammers” present a particularly challenging case for all the models, perhaps due to the fact that correlating affordance of a hammer to a saucepan textually is difficult. In contrast, all models with the augmented prompts typically perform well in the case of creatively replacing “toothpick” with “safety pin” – presumably indicating that specifying the relevant affordance textually in this case provides sufficient information. We repeated each experiment across multiple random seeds and found similar performances, showing that our general findings hold across different random cases. Generally, specifying object affordance information in the prompts leads to improved model performance. Problem solving With High Level Languages 279 IMAGES Free Mini Course: The Language of Problem Solving Problem Solving: Language, strategies and resources C_08 || High Level Language, Need Of Translator How to Teach Problem-Solving code org problem solving process poster Developing Problem-Solving Skills for Kids COMMENTS IN4110 Read more about requirements for submission of assignments, group work and legal cooperation under guidelines for mandatory assignments. It will also be counted as one of your three attempts to sit the exam for this course, if you sit the exam for one of the following courses: IN3110 - Problem Solving with High-Level Languages, INF3331 ... 21 Practical Cognitive Tasks That Work 7. Browse The Web. Review how to open web browsers, use search engines like Google, check email, and close tabs. Even these seemingly simple tasks can be life-changing for motivated patients. 8. Update a Calendar. An ongoing practical cognitive task for patients is updating their calendars. Solving Problems with a High-Level Programming Language Abstract. This chapter presents a general approach to using computers to solve certain kinds of computational problems. It describes instructions and data types common to structured programming with high-level procedural languages and defines a specific strategy for developing algorithms that can easily be translated into a language such as ... High level languages High level languages are similar to the human language. Unlike low level languages, high level languages are programmers friendly, easy to code, debug and maintain. High level language provides higher level of abstraction from machine language. They do not interact directly with the hardware. Rather, they focus more on the complex arithmetic ... 4. Problem Solving and Algorithms The development of an algorithm (a plan) is a key step in solving a problem. Once we have an algorithm, we can translate it into a computer program in some programming language. Our algorithm development process consists of five major steps. Step 1: Obtain a description of the problem. Step 2: Analyze the problem. PDF Introduction to Problem Solving solve a problem, we can write the computer program for giving instructions to the computer in high level language. If the algorithm is correct, computer will run the program correctly, every time. So, the purpose of using an algorithm is to increase the reliability, accuracy Brilliant Progress through lessons and challenges tailored to your level. Designed for ages 13 to 113. Guided bite-sized lessons. We make it easy to stay on track, see your progress, and build your problem-solving skills one concept at a time. Stay motivated. Form a real learning habit with fun content that's always well-paced, game-like progress ... How to think like a programmer Simplest means you know the answer (or are closer to that answer). After that, simplest means this sub-problem being solved doesn't depend on others being solved. Once you solved every sub-problem, connect the dots. Connecting all your "sub-solutions" will give you the solution to the original problem. Congratulations! High-level languages Similarly, for high-level imperative languages there are libraries of functions that can be imported to solve specific problems. For example in Python, one of the things a programmer can do with the random module (library) is to generate a random number — without needing to know exactly how that random number is generated when the code is ... PDF Solving Problems with a High-Level Programming Language interested in solving problems rather than in the operating details of computer systems. In conclusion, the advantage of using a portable, high-level language for problem solving should be clear: you are free to concentrate on solving problems, rather than on the details of how a computer operates. The source code files for High Level Languages: Types & 30 Examples of High Level Language Domain-Specific Languages (DSLs): DSLs are designed for specific application domains or tasks. They have a specialized syntax and vocabulary tailored to the problem they solve. Examples include SQL (for database querying), HTML/CSS (for web development), and MATLAB (for numerical computing).. Markup Languages: Markup languages are used to annotate and structure documents or data. Fifth-generation programming language A fifth-generation programming language ( 5GL) is a high-level programming language based on problem-solving using constraints given to the program, rather than using an algorithm written by a programmer. [ 1] Most constraint-based and logic programming languages and some other declarative languages are fifth-generation languages. What Are High Level Programming Languages: Types and Uses High level programming languages abstract away the details of hardware architecture, allowing developers to focus on solving higher-level problems. With this benefit, developers can efficiently write code without worrying about low-level memory management or processor instructions. Explore High-Level Programming Languages High-level languages, while powerful, face issues such as performance concerns, a steep learning curve for beginners, and compatibility challenges when interfacing with lower-level systems ... High-Level Programming Languages: What Are They? High-level programming languages (or HLPLs) are designed to be easily readable and understood by humans, providing a higher degree of abstraction from the underlying hardware. They simplify the programming process by using more natural language constructs and syntax, which allows developers to focus on problem-solving and logic rather than ... Higher-level language skills by Kate Saunders In a social situation, a child could encounter difficulty if they want to play football but their friend wants to play basketball. This situation requires some problem solving, which is also a higher level language skill. Problem solving involves the ability to recognise the relationship between an action and its outcome. High-Level and Low-Level Programming Languages They provide built-in functions and libraries that simplify common tasks. Programmers can focus on problem-solving and application logic rather than getting bogged down in low-level details. 5 ... Why Python is a High Level Language High-level languages are programming languages designed to be without problems understood and written by way of people ... database access, etc. Who can write great code and could focus on solving higher level problems. Automated Memory Management. Automatic memory management known as garbage collection is implemented in python. As a result, we ... curiousbrutus/Problem-Solving-with-High-Level-Languages Problem-Solving-with-High-Level-Languages This is the repository for -> This folder contains the files I was working on to gain problem solving skills in different languages. Python High-Level Language : Advantages and Disadvantages Easier Learning Curve: High-level languages are typically easier to learn for newcomers to programming, as they abstract away low-level complexities and allow beginners to focus on coding concepts and problem-solving. Disadvantages of High-Level Language. Below we have the disadvantages of High-Level Programming Languages are: Creative Problem Solving in Large Language and Vision Models The high-level plans are then converted to low-level plans for robot execution via LLMs specialized for coding. ... Tree of thoughts: Deliberate problem solving with large language models. arXiv preprint arXiv:2305.10601. Zhang et al. (2023a) Danyang Zhang, Lu Chen, Situo Zhang, Hongshen Xu, Zihan Zhao, ... Problem solving With High Level Languages Problem solving With High Level Languages. I am an applications programmer, when I have a specification for a problem, I normally think about the solution for a while and then the first solution that comes to me I usually design then test the design and then code, then when the prog is running, it is then i test for speed issues and if it runs ... assignment essay homework paper phd report resume review speech thesis