دانلود Lynda Programming Foundations Tutorial Series آموزش اصول و مبانی برنامه نویسی

Topics include:
- Writing source code
- Understanding compiled and interpreted languages
- Requesting input
- Working with numbers, characters, strings, and operators
- Writing conditional code
- Making the code modular
- Writing loops
- Finding patterns in strings
- Working with arrays and collections
- Adopting a programming style
- Reading and writing to various locations
- Debugging
- Managing memory usage
- Learning about other languages

Programming Foundations: Beyond the Fundamentals
Continue your coding journey as you dive deeper into the foundational concepts, practices, and terminology of programming. In this installment of the Programming Foundations series, instructor Sasha Vodnik goes beyond the basics, using Python to tackle a variety of intermediate and advanced concepts and skills you can add to your programming repertoire. Sasha covers creating and working with collections and loops, combining and manipulating strings, and using external code—all of which are critical concepts, regardless of which programming language you end up working with. He goes over several essential processes, such as choosing a code style and debugging. Plus, he digs into a few more advanced concepts, including memory management and multithreading.

Programming Foundations: APIs and Web Services
Web services have been at the core of modern application architectures for many years. Regardless of what language or platform a developer is using, grasping how web services work and how to implement them are critical skills. In this course, instructor Kesha Williams steps through how to work with several popular technologies to build web services. Kesha begins by laying the groundwork for the course, explaining what web services are and the benefits they provide. She then offers a comparison of several popular web service technologies-REST, SOAP, and GraphQL-describing each technology's messaging formats in detail, along with examples of coding in several languages using a variety of server- and client-based implementations. Plus, get coding excerpts in Java, Python, and Swift.
Enjoy!

Topics include:
- What is a web service?
- Securing web services
- Consuming and creating a RESTful API
- Documenting an API
- Creating a web service
- Consuming a SOAP web service
- Developing APIs using GraphQL

Programming Foundations: Algorithms
Algorithms are the universal building blocks of programming. They power the software you use every day, whether it's a spreadsheet, a social network, or a driving assistant. Algorithms offer a way to think about programming challenges in plain English, before they are translated into a specific language like C# or JavaScript. In this course, author and developer Joe Marini explains some of the most popular and useful algorithms for searching and sorting information, working with techniques like recursion, and understanding common data structures. He also discusses the performance implications of different algorithms and how to evaluate the performance of a given algorithm. Each algorithm is shown in practice in Python, but the lessons can be applied to any programming language.

Topics include:
- Measuring algorithm performance
- Working with data structures such as arrays, stacks, and queues
- Looping and recursion
- Sorting data
- Searching data
- Filtering and value counting with hash tables

Programming Foundations: Data Structures
Once you get past simple programs with one or two variables, you'll use data structures to store the values in your applications. Data structures are like containers—there's one for every kind of data. While structures like arrays and queues are sometimes taken for granted, a deeper understanding is vital for any programmer who wants to know what's going on "under the hood" and understand how the choices they've made impact the performance and efficiency of their applications. In this course, Kathryn Hodge provides an in-depth overview of the most essential data structures for modern programming. Starting with simple ways of grouping data, like arrays and structs, Kathryn gradually introduces more complex data structures, such as linked lists, stacks and queues, hash tables, and trees and graphs. Each lesson is accompanied by a real-world, practical example that shows the data structures in action. When you're finished with the course, you'll have a clear understanding of data structures and understand how to use them—in whatever language you're programming in: C#, Swift, JavaScript, Java, Python, and more.

Topics include:
- Data types: Booleans, numbers, strings, and more
- Multidimensional arrays
- Jagged arrays
- Search and sort arrays
- Linked lists
- Stacks and queues
- Hash functions and hash tables
- Trees and graphs

Programming Foundations: Databases
Once you get beyond basic programming, you'll need a database. Databases provide a consistent, organized structure for storing and retrieving large amounts of data. They allow programmers to build more complex applications that can take orders, process payments, make recommendations, authenticate users, and more. This course provides the foundation you need to get started in database programming. Explore the terminology: normal forms, ACID and CRUD, referential integrity, transactions, records, and tables. Learn what role keys and unique values play in a relational model. Discover how to design the best system to contain your data, starting with the tables and relationships at the core of your database. Find out how to write queries to extract the data you need, and how to juggle the different demands of storage, access, performance, and security. Instructor Scott Simpson provides practical examples and clear explanations that will help you design databases that can withstand the needs of your applications, your data, and your users.

Topics include:
- Relational databases
- Keys and unique values
- Planning a database
- Creating tables
- Defining relationships
- Normalization and denormalization
- Writing queries
- Sorting results
- Joining tables
- Modifying data

Programming Foundations: Design Patterns
Design patterns are reusable solutions that solve the challenges software developers face over and over again. Rather than reinventing the wheel, learn how to make use of these proven and tested patterns that will make your software more flexible and resilient to change. This course introduces you to design patterns and takes you through several of the most used object-oriented patterns. Elisabeth Robson and Eric Freeman, coauthors of Head First Design Patterns, join forces to provide an overview of each pattern and examples of the pattern in action. Featured design patterns include the Strategy, Adapter, Observer, and Decorator patterns. Elisabeth and Eric lend these concepts a real-world context by providing code demos in Java, with the occasional example in Python and JavaScript.

Topics include:
- What are design patterns?
- Encapsulating code that varies with the Strategy pattern
- The limitations of inheritance
- Using the Adapter pattern
- Implementing the Observer pattern
- Extending behavior with composition and the Decorator pattern
- Encapsulating iteration with the Iterator pattern
- Object creation with the Factory Method pattern
- Using design principles to guide your object-oriented design

Programming Foundations: Discrete Mathematics
What is discrete math, and how does it apply to programming? Math is an important part of all programming. Discrete mathematics is the study of mathematical structures that are unique (aka discrete). Think integers, graphs, and logical statements—things we use a lot in programming. Discrete math can be used for software design specifications, analysis of algorithms, and other practical applications, but it's really a great tool to develop as a programmer. Put simply, it's a building block for logical thinking.

This course relies on an open-source SML (standard machine language) library to demo the concepts behind discrete math. Peggy Fisher shows you how to manipulate sets of data, write proofs and truth tables, analyze data sequences, and visualize data using graph theory. Challenges at the end of every chapter allow you to test your knowledge. By the end of the course, you should be able to make the leap from theory to using discrete math in practice: saving time and resulting in code that's cleaner and easier to maintain in the long run.

Topics include:
- Real-world discrete math
- Objects as sets
- Set notation and operations
- Standard machine language (SML) setup
- Working with data types, strings, and functions in SML
- Analyzing data sequences
- Writing truth tables
- Identifying and evaluating predicates
- Validating arguments
- Writing proofs: subset, conditional, and biconditional proofs
- Visualizing data with graphs
- Advanced discrete math techniques

Programming Foundations: Fuzzy Logic
Most modern programming is based on exact logic: black or white, yes or no, true or false, 0 or 1. However, we live in a world of partial truths and shades of grey. Fuzzy logic is designed to handle this ambiguity, and help computers more closely approximate human reasoning. In this course, Dr. Erin Colvin introduces fuzzy logic, its benefits, and its contributions to fields such as artificial intelligence and machine learning. Learn about related concepts such as fuzzy set theory and fuzzy inference, with practical examples from real-world applications of the technology.

Programming Foundations: Object-Oriented Design
All good software starts with a great design. Object-oriented design helps developers plan applications before they write a single line of code, and break down ideas into reusable and maintainable components. This course focuses on the foundational concepts, teaching them in a fun, interactive way to help you quickly develop your skills. Tag team Olivia and Barron Stone introduce you to the concepts and terms—objects, classes, abstraction, inheritance, and more—that you need to get started. They then show how to take the requirements for an app, identify use cases, and map out classes using Universal Modeling Language (UML). The final design can then be translated into code using one of the many popular object-oriented programming languages, such as Java, C#, Ruby, or Python.

Topics include:
- Object-oriented basics: objects, classes, and more
- Encapsulation
- Inheritance
- Defining requirements
- Identifying use cases, actors, and scenarios
- Domain modeling
- Identifying class responsibilities and relationships
- Creating class diagrams
- Using abstract classes
- Working with inheritance
- Developing software with object-oriented design principles

Programming Foundations: Open-Source Licensing
Open-source licensing is a way to give back to developer communities and help technology grow at an exponentially faster pace. Open-source licenses allow software to be freely used, modified, or shared, while respecting the original programmer's authorship and intent. Explore the world of open source, and discover how to choose a licensing model for your app, in this Foundations of Programming course with attorney and technologist John V. Petersen.

This is not a coding course. Rather, it's an exploration of the legal and business aspects of open-source software licensing—including topics such as contributor agreements and patent licenses. The major open-source licenses (GPL, MIT, and Apache) are covered in depth, and John also provides an overview of establishing a business entity for your software project: a key factor in the ongoing success of many open-source communities.

Topics include:
- What is a license?
- What is a software license?
- Understanding the principles of open source
- Exploring the three basic licenses: GPL, MIT, and Apache
- Choosing the right open-source license
- Working with Creative Commons
- Dual licensing
- Granting contributor license agreements
- Establishing a legal business entity for your development project

Programming Foundations: Programming for Kids
Kids are naturally excited about building, whether it's building blocks or building rockets. Programming can be just as much fun. And the skills kids gain programming can help them feel accomplished, while giving them a head start in our fast-paced digital world. This course is designed to help parents and educators introduce programming concepts to kids of all ages, from grammar school to high school. David Gassner starts with a description of different learning styles (auditory, kinesthetic, or visual) and talks about how kids' programming tools appeal to different styles. He then introduces mobile device apps for young programmers that let them animate graphical images using simple block-based programming. For older kids, he introduces software such as Scratch for more advanced animation, MIT App Inventor for programming real Android apps, and tools that teach core languages like JavaScript and Java. The final chapter covers how kids can work with robots and other hardware like the Raspberry Pi, which show how programming can work in the real world.

Topics include:
- Understanding your child's learning style
- Graphical programming on iPads and computers
- Making things move
- Learning about algorithms
- Programming animations, apps, and games
- Learning JavaScript and other core languages
- Programming virtual and real robots
- Programming hardware: Arduino and Raspberry Pi

Programming Foundations: Real-World Examples
Understanding core programming concepts and why they are used is just as important as knowing how to write code. New programmers need to learn to bridge the gap: to connect the theory to practice. This series of training videos explains basic programming concepts by relating them to real-life objects, actions, and scenarios. Each video will focus on a different analogy, mixing live action with segments that demonstrate the concepts in code. For example, Barron Stone connects functions to recipes, lists to parking spaces, and loops to that perpetual chore: dishwashing. He illustrates most of the examples using Python, but you can follow along in any language you choose. Start watching and learn about...

Topics include:
- Reusing functions
- Local vs. global variables
- Creating and naming custom objects
- Class inheritance
- Modules and packages
- Multidimensional lists and tuples
- Queues and stacks
- Creating and combining sets
- Storing data in dictionaries
- If/else and switch statements
- For vs. while loops
- Error handling
- Polling and event-driven programming

Programming Foundations: Secure Coding
Learn how to incorporate security into the software development life cycle. Move security into your design and build phases by identifying common insecure code issues and embracing the mindset of a security professional. In this course, security architect Frank Moley provides a basic understanding of secure coding practices. Learn how to understand your attackers and risks and mitigate issues at critical junctures in your code, including thick app, client, and server interactions. Plus, explore how to prevent unauthorized access and data leaks with authentication and cryptography. Frank closes with an overview of security in each phase of the software development life cycle, and next steps for strengthening the security posture of your applications.

Topics include:
- Understanding attackers and risks
- Documenting your risks
- Issues related to web client–server interactions
- Issues related to thick app and client–server interactions
- Authorization and cryptography issues
- Implementing security in each phase of the software development life cycle

Programming Foundations: Software Testing/QA
Quality assurance (QA) engineering can mean many different things to different people. In this course, learn about QA practices within the context of a software engineering project. Instructor Meaghan Lewis demonstrates the different kinds of testing QA focuses on and how QA fits into the software development life cycle (SDLC). Meaghan explores the areas you'll likely want to test and continuously monitor to ensure increasing improvements to your product. Plus, she goes over some of the mechanisms used to communicate the overall health of a product. Upon wrapping up this course, you'll be able to look at whatever you're working on, think critically about how the pieces fit together, and identify ways to help your team meet quality goals with every release.

Topics include:
- How QA fits into the software development life cycle (SDLC)
- Setting expectations and goals
- Making a test plan
- Incorporating box testing into your process
- Executing manual testing
- Leveraging UI automation testing
- Identifying, reporting, and prioritizing bugs

Programming Foundations: Test-Driven Development
Programmers shouldn’t have to guess whether software is working correctly. They should be able to prove it, every step of the way. A formal test-driven development (TDD) process allows you to build testing into your daily routine. You can run tests many times a day, getting instant feedback on the quality of your code. This course explains how to adopt a TDD mindset and process—vital skills for all modern software developers. Find out what makes a good test, why you should be more interested in failure than success, and how to measure and repeatedly run tests. Then explore the jargon: test suites, test harnesses, mock and stub objects, and more. Finally, look at how TDD is used in the most common programming languages and environments and what tools and frameworks exist to help you succeed. Instructor Neelam Dwivedi tackles each topic from a programmer’s perspective, emphasizing the time and cost savings that a good TDD workflow can provide.

Topics include:
- What is test-driven development?
- Writing test cases
- TDD methodology
- Refactoring
- Test structure and syntax
- TDD tools and frameworks
- Mocking

Programming Foundations: Version Control with Git
Manually keeping track of changes to files can slow you down. Version control systems allow developers to off-load this work, as well as safeguard their projects in general. In this course, instructor Christina Truong covers the fundamentals of version control with Git, the popular open-source version control software. Christina helps you get acquainted with basic Git terminology, the basic Git workflow, and how to install the software on both Macs and PCs. She then demonstrates how to manage repositories using either the command line or a graphical user interface (GUI). Along the way, she provides challenges and solutions that help you grasp how these concepts work in practice.

Topics include:
- The benefits of using version control systems
- Essential Git concepts and terminology
- The basic Git workflow
- Using the command line vs. a GUI
- Configuring Git settings
- Setting up local and remote repositories
- Using a GUI to add and commit changes
- Working with branches

Programming Foundations: Web Security
Learn about the most important security concerns when developing websites, and what you can do to keep your servers, software, and data safe from harm. Instructor Kevin Skoglund explains what motivates hackers and their most common methods of attacks, and then details the techniques and mindset needed to craft solutions for these web security challenges. Learn the eight fundamental principles that underlie all security efforts, the importance of filtering input and controlling output, and how to defend against the most common types of attack. This course is essential for developers who want to secure their websites, and for anyone else who wants to learn more about web security.

Topics include:
- Threat models
- Least privilege
- Defense in depth
- Validating and sanitizing input
- Credential attacks
- SQL injection
- Cross-site scripting