Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Python & SoftwareEng: Professional Programming for Beginners

Name: Python & SoftwareEng: Professional Programming for Beginners
Rating: 4.1 (29 reviews)

Hands-on training to become professional software engineers. Learn concepts and practises in a contextual manner.

Created bySriram Vajapeyam

Last updated 5/2021

English

What you'll learn

Basics of Programming
Python programming language
Basics of Programming Methodology
Basics of Software Engineering
Tools such as PyCharm, Git, etc.
Basics of Software Testing
Basics of Graphical User Interface (GUI)
Agile Methodology for software product development
A Planner program that you will build over the course, can use daily for yourself, and can share with others

Coding Exercises

This course includes our updated coding exercises so you can practice your skills as you learn.

Course content

14 sections • 66 lectures • 11h 56m total length

[Programming improves Thinking!] Steve Jobs on Programming1:46
This course aims teach how to think about programs, not just a programming language. Let us start the course by listening to what the man who brought us the iPhone, Steve Jobs, has to say on programming. This will set the theme for the course.
[Program Output] Your First Program: A Planner7:53
This lesson teaches you to write your very first tiny program right away, in a couple of minutes!
Create your own free account on http://www.pythonanywhere.com
Python Cheat Sheet: Introduction
Greet the world!
Programming Languages Python versus C
Share your Program File8:30
This lesson teaches how to save your program in a file on pythonanywhere.com, and how to share your program with others.
It encourages you to start sharing your program with your friends, to get their praise and feedback. The praise will keep you going, the feedback will let you constantly evolve your program into something that others and you will find useful and actually use.
Share your first program with a friend
[Design & Documentation] Start Planning and Organizing your Program10:53
This lesson teaches the maintenance of a feature list: the list of updates to be done to the program.
This lesson teaches program maintenance: keeping the program readable using comments; saving the different versions the program evolves through; etc.
Quiz on myPlanner-1.0.py
Rate Lecture 3!
[Program Input] Wait for User Input!7:06
This lesson teaches how to let the user control the speed of output of the program. It teaches how to wait for and accept a simple <ENTER> key tap from the user.
C code for waiting for user input
[UI; Unit Testing] The User Interface is Important!14:26
This lesson teaches some basics of User Interface design: always keep the user updated about what the program is doing; keep the program output readable; etc.

The lessons also teaches the importance of testing every change to the program: very basic unit testing and regression testing.
Learnings from myPlanner-1.1.py
[Variables] Let the User add one Reminder per Planner invocation19:37
This lesson teaches how to accept text input from the user, remember it
for the current run (execution) of the program, and print it back out.
Remember things in Python
[File Output] Store Reminders in a File18:16
This lectures teaches the separation of program and data. Data (the reminders) are stored in a separate file, and the program (the planner) processes the data (the reminders), reading them in from the reminders file, printing them to the user, and writing them out to the reminders file.

["for" Statement] Repetitively Process Stored Reminders9:06
["if" Statement] Give the User Choice in the Planner's Flow17:02
["while" Stmt] Let the User add Multiple Reminders in single Planner invocation8:07
You will learn about using the Python "while" command.
You will learn to first create a User Interface mock-up of the program feature before actually writing the program code to implement the feature.
[Design Patterns; UI] Enable the User to correct Typos and such9:25
In this lecture you will learn about:
Design Patterns: Introduces the very basics of Design Patterns in code.

User Interface Design: Gets you started on providing a friendly User Interface for the program, one that allows for normal human errors.

[Flowcharts] Let the User switch between Planner Phases anytime15:01
In this lecture you will learn about:

Flowcharts: Decision Diamonds, Action Boxes, and Control Flow.
Program Execution Flow: Control flow during a single execution of a program.
Watch this Movie Clip to Plan the Phase Switching1:15
This gives you a great introduction to timelines! Watch the assignment lecture that has been uploaded as a resource (Lec12-movie-assignment.mp4) and then watch the YouTube movie clip that has been linked to as an external resource for this lecture.
Don't miss the movie clip!
[Program Phases] Plan the Planner's Phase Switches10:25
In this lecture you will learn about:

Program Phases: see how a program could be organized as different phases that the program could be executing in at different times
Constructing Flowcharts: learn to plan a program's code as a flowchart
["break", "else" Stmts] Implement the Planner's Phases: Part 114:11
In this lecture you will learn:

Python Control Statements
flowcharts for Python's control statements
if-then-else, for, while, and break statements

Program Control Flow:
the possible paths through the different program blocks/instructions during program execution
abstracting out the program's control flow using a flowchart
visual approach to mapping a program's control flow onto Python's control statements
["continue" Stmt] Implement the Planner's Phases: Part 219:50
In this lecture you will learn:
Python:
continue statement
Mapping a program's control flow onto Python statements:
top-down/hierarchical mapping
Program Debugging: Your first program BUG!
["Bugs"; Debugging] Planner Phases: Lessons Learnt6:07
In this lecture you will:
review the main learnings from designing the Planner's phases
identify your first program "bug" in the control-flow implementation, and do your first "bug fix"
[Agile Development] Planner Phases: Putting It All Together14:18
In this lecture you will learn:

Agile development:
how to develop a set of program features in multiple small steps, one subset of features at a time, in each step
how to upgrade/enhance the Planner with a subset of the new control flow designed in the previous lecture
Software Testing: How to test if a program works correctly, via:
Unit tests
Regression testing
Corner-case testing.

[IDE: Integrated Development Environment] PyCharm your Planner Phases to code15:29
In this lecture you will learn:

PyCharm, a software tool that makes writing your programs more of a charm!
Tools such as Pycharm are called Integrated Development Environments (IDEs); they are an essential component of the toolkit of a professional programmer.
Folding feature of PyCharm for starters, which lets you navigate your program in an easy hierarchical fashion by folding away code blocks.
External Documentation of your program, which is an important thing to know for working as part of a team of software developers, for using other people's code, and for using or developing software libraries.
Download PyCharm software to your computer
4b: Install Python on your computer
[Pgm Upgrades] Leverage PyCharm and finish the Planner Phases8:12
In this lecture you will learn:

how to upgrade your software program with a new feature
how to work top-down when upgrading your program
how to run your program within PyCharm
[Tidbit:] Working Directories and File Pathnames3:38
In this brief lecture you will learn about "working directories".
File Pathnames

[Version Control (VCS)] A Mental Model for Maintaining your Program Versions6:20
Maintain the different versions of your program in an easier and more professional way, using the software tool "Git".
Git: Use software to maintain program versions
[Git] Walk-through of the first few Git commands16:56
A practical example of using a few basic Git commands to maintain versions of a simple text file on your computer.
Git Basics
[Git] More Shopping with Git10:35
[VCS in IDEs] Using Git in Pycharm7:59
Learn how to use Git both from within Pycharm and from a regular window/terminal but in conjunction with Pycharm.
[VCS Personalized] Meaningful Names for Git Commands5:45
Learn how to make the git commands and their options meaningful to yourself and relatable to the git mental model taught in the course, by assigning meaningful aliases to the git commands.

[Agile: "Backlog"] Planner: Show All Reminders5:45
In true Agile methodology style, decide on the next feature you want to add to your program, and put that on your priority list called "Backlog".
[Functions] Python Functions: Introduction15:22
In this lecture you will learn about "functions" which help modularize your program.
[Parameters] Arguments to a Function19:59
You will learn about passing to a Python function something for it to work with: those things are called "arguments". Another term for "argument" in programming is "parameter". You will not only learn about defining and using functions that take arguments, but also learn the difference between a positional argument and a keyword argument in Python.
You will experience how a function that takes arguments can be used in more places in the program and hence helps make the program more modular and reduces your programming work.
Functions and their arguments
[Mockup & Design] Program Upgrade: UI Mockup and Code Design6:28
In this lecture you will go through the process of first creating a mock-up of the User Interface and then designing the code changes before actually upgrading your program code to implement a new feature.
[Bugs] Upgrading your Program to a Bug.6:16

[Data Structures] Python Lists: An Introduction6:27
Let us maintain the reminders as a list within the program, after reading them in from the reminders file, so that we can access individual reminders in any order we like, any number of times.
Python Cheat Sheet: Lists
[Bugs] Aside: Fix a UI Bug6:53
In this lecture we take a small detour to fix a user-interface bug wherein the option Q to quit the program was not being handled as desirable in the "view reminders" phase of the program.
Re-implement the 'q' user option.
[Functions: Multiple Return Values] Add A List of Reminders to your Planner14:47
In this lecture you will incorporate the Python list data-structure into the planner. You will also learn how to return multiple items from a function, and how to use them.
Python Functions (Built-in)
[Lists] More about Python Lists8:47
In this lecture you will learn that there are many more things you can do with Python lists, and you will learn where to find information about all the supported list operations.
Fix the spurious blank reminders bug
[List index] Jumping around the list of reminders: Specification2:02
In this lecture we will specify as well as see a mock-up of two new planner features: (i) 'p': go to the previous reminder, and (ii) 'g <number>': go to the specified reminder number.
[Strings] Implementation: Jumping around the reminders list16:50
In this lecture we will implement the two new planner features we specified in the previous lecture: (i)'p': go to the previous reminder, and (ii) 'g <number>': go to the specified reminder number. You will learn how to access elements of a list, and you will learn about extracting parts of a string.
Planner version that features Jumping around the reminder list
getUserChoice(extraOption=""): Pass extra options as a LIST instead of as a long STRING
Lists: debug the getSpecListItem() function
[IDE Local History vs. Git] Fix a missed VCS Commit7:33
Learn how to use the Local History feature of PyCharm. Local History is different from Git or other VCS.
[List deletions] Delete reminders4:11
In this lecture you will learn how to easily delete items from a Python list.

[Scope] The Problem of Variable Visibility10:35
You will see for the first time that variable names have different visibilities within and outside functions in a simple, single-file Python program.
[Scope] Local and Global Variables14:33
You will learn the basic rules of scope for variable names in Python: in what parts of the program is a variable name visible?
[Scope] Parameters to Functions7:17
You will learn about how parameters passed to functions work: their scope.
[Refactoring] Localize the Reminders list operations - 111:53
You will reorganize (i.e., refactor) the planner such that the index into the reminders list is modified only within the set of functions associated with the reminders list, that too without passing the index as a parameter to the functions. You will also learn how to convert a piece of code into a function automatically in PyCharm.
[Parameters] Call by Reference / Output Parameters11:50
You will learn about parameters-by-reference: how to return the work of a function through one of its parameters, instead of as return values.

Requirements

No previous knowledge of programming is needed.
Interest in learning programming hands-on, alongside the instructor.
Access to a netbook/laptop/desktop computer (Linux preferred, Mac fine, Windows ok)
Willingness to learn to be logical, systematic, precise, patient, and persistent in your work.

Description

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

Steve Jobs, the man who brought us the iPhone said:

"I think every body in this country should learn how to program a computer.. should learn a computer language... because it teaches you how to think."

"I view computer science as a liberal art. It should be something that everybody learns... takes a year in their lives.. one of the courses they take is .. learning how to program." [ -- Steve Jobs: The Lost Interview, 1995]

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

This course teaches you how to think, about computer programs; it doesn't just teach you a programming language.

Along the way, want to learn programming? Eager to become a software engineer? How about learning the basics of the world's hottest programming language Python, wildly popular software engineering tools, and excellent programming methodology?

This hands-on, continuously evolving course that will grow to have 20+ hours of screen-cast programming-session recordings will teach you -- a novice -- how to create useful computer programs that people can use, and how to continually upgrade your programs with new features based on user requirements. In fact, you will build and evolve your own program, "myPlanner", during the course, alongside evolving your programming skills. Read the storyline of the program's evolution in the resources section of the very first lecture or the "Future Lectures!" section, both of which are available for free preview.

The Python programming language is ranked as the hottest programming language on the planet right now. (Search the internet for "Python popularity" and see for yourself!) Python is also a popular platform for the wildly in-demand programming job of data scientist. This course teaches Python and how to use it in a professional manner.

Software engineering tools such as Integrated Development Environments and Version Control Systems, program development methodologies such as Agile, and programming skills such as requirement specification, top-down design, object-oriented design, and software testing are essential requirements for a software engineer. This course teaches the basics of all these tools, methodologies, and skills.

The attraction of this course is that it is designed to help you learn the basics of all the above in a natural and easy manner by taking you on a guided tour of evolving your own computer program. At each stage of your program's evolution you will learn the necessary tools, processes, and methodologies just exactly when you need them, thus building in your mind a nice, complete and memorable storyline of all the things you learn.

This holistic course is a combination of two courses that are often taught separately: a programming language course and a software engineering course. Each video lecture is a programming session captured on screen rather than a talking head and power-point slides, and downloadable for every lecture is the fully working program developed in that lecture!

Here are some of the highly marketable skills you will acquire from this course:

Python programming language
Agile Methodolgy
Requirements specification
Top-down Program design
Flowcharts
Object-Oriented Programming (OOP)
Software Testing
PyCharm IDE (Integrated Development Environment)
GIT Version Control System
User Interface (UI) design
etc., etc., etc.

So, hop on board, join the class and become a software engineer!

Target Audience:

You want to become a professional programmer but have no prior programming background
You want to learn the Python programming language and the basics of software engineering
You want to re-learn programming in a better way

Skills Needed:

You already have or are willing to develop the habits of precise, logical, and systematic thinking and expression, being organized in your work, and persistence and patience. This course will not only make you a very good beginning programmer, but also perhaps make your approach to all other work as well more methodical.

Course Mechanics:

In the very first lecture you will build your very first program, and with each subsequent lecture you will grow your program organically into something bigger, along the way learning all the different tools, methods, processes and methodologies required.

Thus, you will pickup the basics of all the different skills needed towards becoming a professional programmer, not just a particular programming language. Just as becoming a good writer involves much more than learning English grammar and vocabulary, becoming a good programmer involves much more than just learning a programming language. This course will start you on the path to becoming a good programmer.

As you progress in the course, not only will you have your own working Planner program that you can show off to your friends, but also you will grow a beginner programmer skill set of the most in-demand things in the software industry.

Additional Course Lectures:

This course provides you a unique opportunity to shape the lectures to your benefit. The course has been seeded with an initial 20 lectures, and at least as many more lectures are in preparation and will be added to the course in the near future. These latter lectures will take into account all student feedback on the initial seed lectures. Such development of any product, based on user feedback and involving many releases/upgrades, is referred to as Agile Product Development, a methodology that is taught in this course. Your feedback will shape not only what is taught next but also how it is taught. The earlier you join the course and the more feedback you give, the more you can shape this course to your liking!

Course Outcomes:

Computer programming is not just about learning a programming language. In this course you will learn in an easy, enjoyable, and motivating manner how to develop working software programs, that is, the basics of Software Engineering. You will be learning the Python programming language along the way.

Who this course is for:

You want to learn HOW TO program.
You want to learn Python in a memorable way.
You want to become a Software Engineer.
You know some programming language already but want to learn software engineering.
You want to learn by programming rather than just from lectures, slides or text books.
You want to re-learn the basics of programming and software engineering in a proper way.
You are a manager who wants to understand what goes into software development.
You want to improve your thinking skills!

Python & SoftwareEng: Professional Programming for Beginners

What you'll learn

Explore related topics

Coding Exercises

Course content

Introduction: Start Programming Now8 lectures • 1hr 28min

Decisions: Control Flow in Programs -- The Basics4 lectures • 44min

Code Flow: Flowcharts - An Aid for Designing your Program7 lectures • 1hr 21min

Programming Tools: PyCharm -- An Integrated Development Environment (IDE)3 lectures • 27min

Code Versions: Git -- A Popular Version Control System (VCS)5 lectures • 48min

Repetitive Tasks: Loops -- Conditionals, Exits2 lectures • 28min

Code Reuse: Functions5 lectures • 54min

Errors: Program Debugging -- A First Session1 lecture • 11min

Lists: Maintaining Lists of Things in Python8 lectures • 1hr 8min

Variables: Values, Names, Types and Scope5 lectures • 56min

Requirements

Description

Who this course is for: