Skip to main content
5 answers
5
Asked 203 views Translate

How do absorb or learn technical functions in programming languages?

I am an IT student. Having a hard time memorizing the functions in Python and figuring out what the "problem" needs. Like I know what is the flow of the "program" but I have no idea what functions or specific commands to use.

+25 Karma if successful
From: You
To: Friend
Subject: Career question for you

5

5 answers


1
Updated Translate

Jay’s Answer

Learning how to code in a programming language is like learning to read, write, and speak a foreign language. There are intricacies that can change the entire meaning or context of the language which is why it is extremely difficult for many people. Even as a native English speaker, I still struggle with nuance. Thankfully, we have the luxury of information at our fingertips for discovering syntax and common troubleshooting tips when the functionality does not work as intended. In my profession, and in my years of developing code in numerous different programming languages, I have come to terms with several absolutes that have changed my frame of reference or way of thinking when approaching a programming language.

1.) Programming languages evolve over time.
2.) Understand what may have worked in the past, may not work in the future.
3.) Expect and build for failure so you aren't surprised when it happens.
4.) Truly understand what your code is supposed to do, and what both successful and failed states should look like.
5.) Finally, use Google (or similar external resource) as an extension of the storage section of your brain.

I personally do not have photographic memory and very rarely remember exact syntax. I spend more of my time learning about concepts and fundamentals, because I have realized that the syntax is likely going to change to take advantage of new technologies, features, functionality, or dependencies. I have also come to the understanding that a class or method that I built on previous versions of libraries are likely going to break and my code will need to be modified because of some syntactical nuance that a newer version has required or implemented. I fully expect my code to break; whether it be from syntax, deprecation, and/or dependency. It is my job as a developer to try and mitigate that as much as possible, so we test for success and test for failure. Many times you will be working on a project or application and it will grow in scope (aka. "Feature Creep") -- requirements will be defined, features will be added (or removed), and the path to move from point-A to point-Z may not be a straight one. Having a real understanding of what your application is supposed to do and how it should look in both successful and failed states will help you decide how to write the code. Once you understand these principals, you begin to understand that there is no shame in using external resources (Google, for example) to figure out how to pass that parameter to a function, or what a specific response is and how it's formatted.

Hope this helps! I am always available to help clarify any of this and to provide additional insight if that is helpful!
1
1
Updated Translate

Rebecca’s Answer

Thank you for your question.
It’s true sometimes it may not easy to memorise all the syntax. Practise makes perfect! Instead of hard memorise the function, you can remember the functions when you code more.
Below is my suggestions:
1. Firstly, you can read the project/ assignment thoroughly to understand what the outcome to achieve.
2. You can then analyse how the process the input into the outcome.
3. Put down the process logic into pseudo code
4. Convert the pseudo code into the programming language
5. Test the program
Hope this helps! Good Luck!
1
0
Updated Translate

Brenda’s Answer

Learning anything new takes time. Continue reading code and follow the flow. Practice solving various problems and research how others solve similar issues. Be sure to ask questions and talk through your code with someone else. Whenever you share you will solidify the concept more with yourself. Start a journal - you will be amazed at your own progress over time.
0
0
Updated Translate

Douglas’s Answer

Shaina,

Hi. So you states you know how to write the flow of a program, good.

Next is to learn about all the python variable types (if you
google that you'll find a number of web pages with lists of types)

The functions that you will use depends on the task you are doing.

To learn which function (and module) you need to use for a task,
you need to know how to describe the task. Before Google, we
would look up in the index of a book "yaml" and we would
find the section about how to read/write yaml files.
Now, we can google: python load yaml file
or python write yaml file

It is important to learn about using databases and how to write programs
to read and save data into databases.

Unless you are taking a test, you do not need to memorize functions,
over time of using the functions you'll remember the names and there
are many cheat sheets for modules and functions.

And to learn about what tasks companies are looking for google:
python jobs and look at the areas (database, API, and frameworks
they are looking for)

Douglas recommends the following next steps:

Learn all Python variable types
Google the programming tasks for examples and to learn which functions/modules are used
Read 5 programming Python tutorials - to continue to learning Python
0
0
Updated Translate

John’s Answer

Pattern recognition is one of the biggest skills in software development. As you tackle more and more problems (both the large-scale problems, and the smaller problems that you can break down those large ones into), you'll start to run into similar problems, and can apply your past skills to this one.

9 times out of 10, a problem isn't completely new to us. We can break it down into smaller problems (which might even be broken down further) that we've seen before. Sure, the specifics might be different (sorting a list of books, versus sorting a list of bank transactions), but once we zoom out, it's the same problem.

The nice thing about software is that it's never a closed-book test, you can always look up what you're trying to do. Again, 9 times out of 10, the problem isn't new. In fact, someone else has probably solved it before. The internet is a treasure trove of answers

And by the same token, we're always learning new things. There are always new languages, new features, and new tools to get the job done, and it's our job as developers to keep up. We all go through the exact situation you're describing, so you're in good company 🙂
0