Programming and scripting languages: general Books

Book SynopsisWith traditional software unit tests, there’s never a guarantee that an application will actually function correctly in the production environment. When you add microservices, testing becomes even more tricky. Testing Java Microservices teaches readers how to write tests like unit, component, integration, container, contract, chaos, and more. Along the way, it also covers technologies like the Arquillian ecosystem, Wiremock, Mockito, AssertJ, Pact or Gatling. Finally, the book demonstrates how everything fits together into the Continuous Delivery pipeline. Key Features: · Practical hands-on guide · Writing Persistence tests · Teaches test strategies · Shows how everything fits together in the Continuous Delivery Pipeline Readers should be comfortable programming in Java. Experience with testing tools like jUnit is helpful but not required. Some experience in Java EE, Spring and Docker is also helpful. About the Technology: A microservice may consist of several, several hundred, or even several thousand of lines of code. Microservices enable programmers to isolate and scale smaller pieces of an application, rather than the entire application.

Read more less

Book SynopsisCSS lets programmers precisely specify the visual design of a web page or web app, from the structural layout of elements on the page to their individual look and feel. CSS in Depth takes web developers from beginner to advanced. In this book, they will revisit concepts that they are likely familiar with but have not completely mastered. Key Features: · Teaches the cascade, floats, and positioning · Example-rich · Covers both beginner and advanced topics This book is for both experienced and new web developers who want to deepen their knowledge of CSS. It assumes you have some basic experience with HTML, CSS, and the web. Some familiarity with JavaScript or other C-like programming language may be beneficial, but not required. About the Technology: CSS, short for “Cascading Style Sheets”, is one of the foundational technologies that drives the Internet. It specifies the visual design of a web page or web app, from the structural layout of elements on the page to their individual look and feel.

Read more less

Book SynopsisDESCRIPTION Serverless architecture is about having more time to focus on code, and moving quickly. In these new architectures, traditional back-end servers are replaced with cloud functions acting as discrete singlepurpose services. With serverless compute technologies like AWS Lambda, developers can build entirely serverless platforms at scale. Serverless Architectures on AWS teaches how to build, secure and manage serverless architectures that can power the most demanding web and mobile apps. This book has many ready-made and real-world examples, code snippets, diagrams, and descriptions of architectures that can be readily applied. It describes a traditional application and its back end concerns and then shows how to solve these same problems with a serverless approach. By the end, readers will be able to reason about serverless systems and be able to compose their own systems by applying these ideas and examples. KEY FEATURES • Up-to-date with the most current platform trends • Real-world examples, code snippets, and diagrams• Learn to solve back end concerns with a serverless approach AUDIENCE This book is for all software developers interested in back end technologies. Experience with JavaScript (node.js) and AWS is useful but not required. ABOUT THE TECHNOLOGY Lambda is a compute service that executes code written in JavaScript (node.js), Python, or Java on AWS infrastructure. Source code is deployed to an isolated container that has its own allocation of memory, disk space, and CPU. Serverless architectures herald a new way of building scalable, powerful, cost-effective, and high-performing back end systems. They encourage a new way of creating applications through the use of a stateless compute service to execute code.

Read more less

Book SynopsisEnter the Web Design Playground and start experimenting with all aspects of creating a web page—from design, to development, to publishing—in an easy-to-use free online workspace. Suitable for anyone interested in creating web pages. In Web Design Playground, Second Edition you'll learn essential tools of the web design trade, such as: Structuring a web page with HTML Styling a web page with CSS Modern page layout techniques Using colors in web design Making text look awesome with typography About the technology HTML, CSS, and the principles of good web design are all you need to build something beautiful! You'll find them all inside this one-of-a-kind guide. Written by web designer and master teacher Paul McFedries, this unique book shapes and sharpens your skills in the always-relevant technologies of the web.

Read more less

Book SynopsisWrite code that writes code with Elixir macros. Macros make metaprogramming possible and define the language itself. In this book, you'll learn how to use macros to extend the language with fast, maintainable code and share functionality in ways you never thought possible. You'll discover how to extend Elixir with your own first-class features, optimize performance, and create domain-specific languages. Metaprogramming is one of Elixir's greatest features. Maybe you've played with the basics or written a few macros. Now you want to take it to the next level. This book is a guided series of metaprogramming tutorials that take you step by step to metaprogramming mastery. You'll extend Elixir with powerful features and write faster, more maintainable programs in ways unmatched by other languages. You'll start with the basics of Elixir's metaprogramming system and find out how macros interact with Elixir's abstract format. Then you'll extend Elixir with your own first-class features, write a testing framework, and discover how Elixir treats source code as building blocks, rather than rote lines of instructions. You'll continue your journey by using advanced code generation to create essential libraries in strikingly few lines of code. Finally, you'll create domain-specific languages and learn when and where to apply your skills effectively. When you're done, you will have mastered metaprogramming, gained insights into Elixir's internals, and have the confidence to leverage macros to their full potential in your own projects.

Read more less

Book SynopsisFearlessly change the design of your iOS code with solid unit tests. Use Xcode's built-in test framework XCTest and Swift to get rapid feedback on all your code - including legacy code. Learn the tricks and techniques of testing all iOS code, especially view controllers (UIViewControllers), which are critical to iOS apps. Learn to isolate and replace dependencies in legacy code written without tests. Practice safe refactoring that makes these tests possible, and watch all your changes get verified quickly and automatically. Make even the boldest code changes with complete confidence. Manual code and UI testing get slower the deeper your navigation hierarchy goes. It can take several taps just to reach a particular screen, never mind the actual workflow tests. Automatic unit testing offers such rapid feedback that it can change the rules of development. Bring testing to iOS development, even for legacy code. Use XCTest to write unit tests in Swift for all your code. iOS developers typically reserve unit tests for their model classes alone. But that approach skips most of the code common to iOS apps, especially with UIViewControllers. Learn how to unit test these view controllers to expand your unit testing possibilities. Since good unit tests form the bedrock for safe refactoring, you're empowered to make bold changes. Learn how to avoid the most common mistakes Swift programmers make with the XCTest framework. Use code coverage to find holes in your test suites. Learn how to identify hard dependencies. Reshape the design of your code quickly, with less risk and less fear.

Read more less

Book SynopsisDesign and develop sophisticated 2D games that are as much fun to make as they are to play. From particle effects and pathfinding to social integration and monetization, this complete tour of Apple's powerful suite of game technologies covers it all. Familiar with Swift but new to game development? No problem. Start with the basics and then layer in the complexity as you work your way through three exciting - and fully playable - games. In the end, you'll know everything you need to go off and create your own video game masterpiece for any Apple platform. Discover the power of Apple Game Frameworks, Xcode, and Swift by building three exciting games: Gloop Drop - a new twist on a classic arcade game, Val's Revenge - a roguelike dungeon crawler, and Hog - a social player vs. player mobile dice game. With Apple Game Frameworks, you can create high-performance, power-efficient games that work across all Apple platforms, including iOS, macOS, tvOS, and watchOS. In this book, you'll discover how to... Design and develop rich 2D gaming experiences using Apple's built-in game frameworks. Harness the power of SpriteKit using Xcode and Swift to create engaging player experiences. Use the visual Scene Editor to build complete scenes. Unleash the power of the Particle Editor to create amazing effects. Use GameplayKit to add advanced features to your games like pathfinding, artificial intelligence, and complex rule systems. Build larger, more complex worlds with tile maps and Xcode's visual Tile Map editor. Bring people together using GameKit and Game Center, Apple's social gaming network. Increase revenue with third-party banner ads and rewarded ads using Google AdMob (TM). Monetize your games with StoreKit and in-app purchases. So, grab your gear and get your game on - it's time to level up your skills. What You Need: macOS Mojave 10.14.6 or newer Xcode 11.3 or newer Basic knowledge of Swift 5.1.4 or newer

Read more less

Book SynopsisRust is an exciting new programming language combining the power of C with memory safety, fearless concurrency, and productivity boosters - and what better way to learn than by making games. Each chapter in this book presents hands-on, practical projects ranging from "Hello, World" to building a full dungeon crawler game. With this book, you'll learn game development skills applicable to other engines, including Unity and Unreal. Rust is an exciting programming language combining the power of C with memory safety, fearless concurrency, and productivity boosters. With Rust, you have a shiny new playground where your game ideas can flourish. Each chapter in this book presents hands-on, practical projects that take you on a journey from "Hello, World" to building a full dungeon crawler game. Start by setting up Rust and getting comfortable with your development environment. Learn the language basics with practical examples as you make your own version of Flappy Bird. Discover what it takes to randomly generate dungeons and populate them with monsters as you build a complete dungeon crawl game. Run game systems concurrently for high-performance and fast game-play, while retaining the ability to debug your program. Unleash your creativity with magical items, tougher monsters, and intricate dungeon design. Add layered graphics and polish your game with style. What You Need: A computer running Windows 10, Linux, or Mac OS X. A text editor, such as Visual Studio Code. A video card and drivers capable of running OpenGL 3.2.

Read more less

Book SynopsisMake your good Python code even better by following proven and effective pythonic programming tips. Avoid logical errors that usually go undetected by Python linters and code formatters, such as frequent data look-ups in long lists, improper use of local and global variables, and mishandled user input. Discover rare language features, like rational numbers, set comprehensions, counters, and pickling, that may boost your productivity. Discover how to apply general programming patterns, including caching, in your Python code. Become a better-than-average Python programmer, and develop self-documented, maintainable, easy-to-understand programs that are fast to run and hard to break. Python is one of the most popular and rapidly growing modern programming languages. With more than 200 standard libraries and even more third-party libraries, it reaches into the software development areas as diverse as artificial intelligence, bioinformatics, natural language processing, and computer vision. Find out how to improve your understanding of the spirit of the language by using one hundred pythonic tips to make your code safer, faster, and better documented. This programming style manual is a quick reference of helpful hints and a random source of inspiration. Choose the suitable data structures for searching and sorting jobs and become aware of how a wrong choice may cause your application to be completely ineffective. Understand global and local variables, class and instance attributes, and information-hiding techniques. Create functions with flexible interfaces. Manage intermediate computation results by caching them in files and memory to improve performance and reliability. Polish your documentation skills to make your code easy for other programmers to understand. As a bonus, discover Easter eggs cleverly planted in the standard library by its developers. Polish, secure, and speed-up your Python applications, and make them easier to maintain by following pythonic programming tips. What You Need: You will need a Python interpreter (ideally, version 3.4 or above) and the standard Python library that usually comes with the interpreter.

Read more less

Book SynopsisArchitect scalable, reliable, and maintainable applications for enterprises with PythonKey Features Explore various Python design patterns used for enterprise software development Apply best practices for testing and performance optimization to build stable applications Learn about different attacking strategies used on enterprise applications and how to avoid them Book DescriptionDynamically typed languages like Python are continuously improving. With the addition of exciting new features and a wide selection of modern libraries and frameworks, Python has emerged as an ideal language for developing enterprise applications. Hands-On Enterprise Application Development with Python will show you how to build effective applications that are stable, secure, and easily scalable.The book is a detailed guide to building an end-to-end enterprise-grade application in Python. You will learn how to effectively implement Python features and design patterns that will positively impact your application lifecycle. The book also covers advanced concurrency techniques that will help you build a RESTful application with an optimized frontend. Given that security and stability are the foundation for an enterprise application, you’ll be trained on effective testing, performance analysis, and security practices, and understand how to embed them in your codebase during the initial phase. You’ll also be guided in how to move on from a monolithic architecture to one that is service oriented, leveraging microservices and serverless deployment techniques.By the end of the book, you will have become proficient at building efficient enterprise applications in Python.What you will learn Understand the purpose of design patterns and their impact on application lifecycle Build applications that can handle large amounts of data-intensive operations Uncover advanced concurrency techniques and discover how to handle a large number of requests in production Optimize frontends to improve the client-side experience of your application Effective testing and performance profiling techniques to detect issues in applications early in the development cycle Build applications with a focus on security Implement large applications as microservices to improve scalability Who this book is forIf you’re a developer who wants to build enterprise-grade applications, this book is for you. Basic to intermediate-level of programming experience with Python and database systems is required to understand the concepts covered in this book.Table of ContentsTable of Contents Using Python for Enterprise Design Patterns: Making a Choice Building for Large Scale Database Operations Dealing with Concurrency Building for Large Scale Request Handling Example: Building BugZot Building Optimized Frontends Writing Testable Code Profiling Applications for Performance Securing Your Application Taking the Microservices Approach Testing and Tracing in Microservices Going Serverless Deploying to the Cloud Enterprise Application Integration and its Patterns Microservices and Enterprise Application Integration

Read more less

Book SynopsisGO Programming in easy steps has an easy-to-follow style that will appeal to anyone who wants to begin coding computer programs with Google's Go programming language. The code in the listed steps within the book is color-coded making it easier for beginners to grasp. You need have no previous knowledge of any computer programming language so it''s ideal for the newcomer.GO Programming in easy steps instructs you how to write code to create your own computer programs. It contains separate chapters demonstrating how to store information in data structures, how to control program flow using control structures, and how to create re-usable blocks of code in program functions. There are complete step-by-step example programs that demonstrate each aspect of coding, together with screenshots that illustrate the actual output when each program is executed. GO Programming in easy steps begins by explaining how to easily create a programming environment on your own computer, so you can quickly begin to create your own working programs by copying the book''s examples. After demonstrating the essential building blocks of computer programming it describes how to use data abstraction for object-oriented programming and demonstrates how to code goroutines and channels for concurrency in your programs.

Read more less

Book SynopsisPHP in easy steps, 4th edition demonstrates every aspect of the language you'll need to produce professional web programming results. Its examples provide clear syntax-highlighted code, which is freely downloadable, showing PHP language basics including variables, arrays, logic, looping, functions and classes.Install a free web server and the PHP interpreter to create an environment in which you can produce your own data-driven web pages.Write PHP server-side scripts; master PHP operators and control structures; process HTML form data; get cookies and session data; access Web Services APIs over HTTP... and much more! PHP in easy steps, 4th edition is ideal for PHP newbies who want to quickly learn the fundamentals of server-side programming with PHP and create interactive web pages. Also, useful for PHP pros who want to grasp the new PHP 8 features and achieve optimum performance!Updated for PHP 8.

Read more less

Book SynopsisThis book, written by Phil Bagge and published in conjunction with Hampshire Inspection and Advisory Service (HIAS), has been devised for children of KS2 (Year 5 and 6) age to learn programming outside of school.It contains a series of programming projects that gradually introduce children to algorithm design, evaluation and generalisation. Children will learn how to use selection, procedures and variables through becoming creators of a wide variety of programming projects. Maths, literacy, humanities, gaming and music are all put to the test. Read the short introduction to find out more.The Scratch programming language, widely recognised in schools, is freely accessible online or as a download and is the ideal place to begin programming.

Read more less

Book SynopsisThese books, classroom-tested and perfected by Phil Bagge through his website code-it.co.uk and published in conjunction with Hampshire Inspection and Advisory Service (HIAS), aid teachers in providing Key Stage 2 pupils with an exciting and challenging computer science curriculum.They can be used to supplement existing programming modules or as a complete KS2 computer science program of study. They contain a series of programming projects that gradually introduce pupils to algorithm design and evaluation, generalisation and decomposition. Pupils will learn how to use sequence, repetition, selection and variables through becoming creators of a wide variety of programming projects. Maths, literacy, humanities, gaming, music and control skills are all put to the test.There are four pupil workbooks to provide structure, resources and home learning links. These are designed to work in conjunction with the teacher book. In addition, there are also two home learning books that have been devised for children to learn programming outside of school. A growing bank of online videos are also available, designed to help teachers improve their own skills and take full advantage of the crosscurricular benefits of developing depth in programming.The Scratch programming language, widely recognised in schools, is freely accessible online or as a download and is the ideal place to begin programming.

Read more less

Book SynopsisThese books, classroom-tested and perfected by Phil Bagge through his website code-it.co.uk and published in conjunction with Hampshire Inspection and Advisory Service (HIAS), aid teachers in providing Key Stage 2 pupils with an exciting and challenging computer science curriculum.They can be used to supplement existing programming modules or as a complete KS2 computer science program of study. They contain a series of programming projects that gradually introduce pupils to algorithm design and evaluation, generalisation and decomposition. Pupils will learn how to use sequence, repetition, selection and variables through becoming creators of a wide variety of programming projects. Maths, literacy, humanities, gaming, music and control skills are all put to the test.There are four pupil workbooks to provide structure, resources and home learning links. These are designed to work in conjunction with the teacher book. In addition, there are also two home learning books that have been devised for children to learn programming outside of school. A growing bank of online videos are also available, designed to help teachers improve their own skills and take full advantage of the crosscurricular benefits of developing depth in programming.The Scratch programming language, widely recognised in schools, is freely accessible online or as a download and is the ideal place to begin programming.

Read more less

Book SynopsisRuby, Io, Prolog, Scala, Erlang, Clojure, Haskell. With Seven Languages in Seven Weeks, by Bruce A. Tate, you'll go beyond the syntax-and beyond the 20-minute tutorial you'll find someplace online. This book has an audacious goal: to present a meaningful exploration of seven languages within a single book. Rather than serve as a complete reference or installation guide, Seven Languages hits what's essential and unique about each language. Moreover, this approach will help teach you how to grok new languages. For each language, you'll solve a nontrivial problem, using techniques that show off the language's most important features. As the book proceeds, you'll discover the strengths and weaknesses of the languages, while dissecting the process of learning languages quickly--for example, finding the typing and programming models, decision structures, and how you interact with them. Among this group of seven, you'll explore the most critical programming models of our time. Learn the dynamic typing that makes Ruby, Python, and Perl so flexible and compelling. Understand the underlying prototype system that's at the heart of JavaScript. See how pattern matching in Prolog shaped the development of Scala and Erlang. Discover how pure functional programming in Haskell is different from the Lisp family of languages, including Clojure. Explore the concurrency techniques that are quickly becoming the backbone of a new generation of Internet applications. Find out how to use Erlang's let-it-crash philosophy for building fault-tolerant systems. Understand the actor model that drives concurrency design in Io and Scala. Learn how Clojure uses versioning to solve some of the most difficult concurrency problems. It's all here, all in one place. Use the concepts from one language to find creative solutions in another-or discover a language that may become one of your favorites.

Read more less

Book SynopsisGreat programmers aren't born--they're made. The industry is moving from object-oriented languages to functional languages, and you need to commit to radical improvement. New programming languages arm you with the tools and idioms you need to refine your craft. While other language primers take you through basic installation and "Hello, World," we aim higher. Each language in Seven More Languages in Seven Weeks will take you on a step-by-step journey through the most important paradigms of our time. You'll learn seven exciting languages: Lua, Factor, Elixir, Elm, Julia, MiniKanren, and Idris. Learn from the award-winning programming series that inspired the Elixir language. Hear how other programmers across broadly different communities solve problems important enough to compel language development. Expand your perspective, and learn to solve multicore and distribution problems. In each language, you'll solve a non-trivial problem, using the techniques that make that language special. Write a fully functional game in Elm, without a single callback, that compiles to JavaScript so you can deploy it in any browser. Write a logic program in Clojure using a programming model, MiniKanren, that is as powerful as Prolog but much better at interacting with the outside world. Build a distributed program in Elixir with Lisp-style macros, rich Ruby-like syntax, and the richness of the Erlang virtual machine. Build your own object layer in Lua, a statistical program in Julia, a proof in code with Idris, and a quiz game in Factor. When you're done, you'll have written programs in five different programming paradigms that were written on three different continents. You'll have explored four languages on the leading edge, invented in the past five years, and three more radically different languages, each with something significant to teach you

Read more less

Book SynopsisThis textbook is a thorough, up-to-date introduction to the principles and techniques that guide the design and implementation of modern programming languages. The goal of the book is to provide the basis for a critical understanding of most modern programming languages. Thus, rather than focusing on a specific language, the book identifies the most important principles shared by large classes of languages. The notion of ‘abstract machine’ is a unifying concept that helps to maintain an accurate and elementary treatment. The book introduces, analyses in depth, and compares the imperative, object-oriented, functional, logic, concurrent, constraint-based, and service-oriented programming paradigms. All material coming from the first English edition has been updated and extended, clarifying some tricky points, and discussing newer programming languages. This second edition contains new chapters dedicated to constraint, concurrent, and service-oriented programming.Topics and features: Requires familiarity with one programming language is a prerequisite Provides a chapter on history offering context for most of the constructs in use today Presents an elementary account of semantical approaches and of computability Introduces new examples in modern programming languages like Python or Scala Offers a chapter that opens a perspective on applications in artificial intelligence Conceived as a university textbook, this unique volume will also be suitable for IT specialists who want to deepen their knowledge of the mechanisms behind the languages they use. The choice of themes and the presentation style are largely influenced by the experience of teaching the content as part of a bachelor's degree in computer science.Table of Contents1. Abstract Machines.- 2. How to Describe a Programming Language.- 3. Foundations.- 4. Names and the Environment.- 5. Memory Management.- 6. Control Structure.- 7. Control Abstraction.- Structuring Data.- 8. Data Abstraction.- 9. The Object-Oriented Paradigm.- 10. The Functional Paradigm.- 11. The Logic Programming Paradigm.- 12. A Short Historical Perspective.

Read more less

Book SynopsisThis textbook is aimed at readers who have little or no knowledge of computer programming but want to learn to program in Python. It starts from the very basics including how to install your Python environment, how to write a very simple program and run it, what a variable is, what an if statement is, how iteration works using for and while loops as well as important key concepts such as functions, classes and modules. Each subject area is prefaced with an introductory chapter, before continuing with how these ideas work in Python. The second edition has been completely updated for the latest versions of Python including Python 3.11 and Python 3.12. New chapters have been added such as those that consider where and how Python is used, the use of Frozensets, how data can be sorted, enumerated types in Python, structural pattern matching and how (and why) Python Virtual Environments are configured. A new chapter ‘The Python Bites back’ is introduced to present the fourteen most common / biggest gotchas for someone new to Python. Other sections have been updated with new features such as Exception Groups, string operations and dictionary operations. A Beginners Guide to Python 3 Programming second Edition provides all you need to know about Python, with numerous examples provided throughout including several larger worked case studies illustrating the ideas presented in the previous chapters.Table of ContentsIntroduction.- Where is Python Used.- Setting up the Python Environment.- A First Python Program.- Python Strings.- Numbers, Booleans and None.- Flow of Control using if statements.- Number Guessing Game.- Recursion.- Introduction to Structured Analysis.- Functions in Python.- Implementing a Calculator using Functions.- Introduction to Functional Programming.- Curried Functions.- Introduction to Object Orientation.- Class Side and Static Behaviour.- Why Bother with Object Orientation?.- Operator Overloading.- Error and Exception Handling.- Python Modules and Packages.- Abstract Base Classes.- Error and Exception Handling.- Python Modules and Packages.- Protocols, Polymorphism and Descriptors.- Decorators.- Iterables and Iterators.- Generators and Coroutines.- Collections Tuples and Lists.- Sets.- Dictionaries.- Frozensets.- Collection Related Modules.- ADTs, Queues and Stacks.- Map, Filter and Reduce.- Sorting and Higher Order Functions.- Python Enumerated Values, Structural Pattern Making.- Python Virtual Environments.- Monkey Patching.- Attribute Lookup.- The Python Bites Back.- TicTacToe Game.

Read more less

Book SynopsisThis book provides a unique tour of university mathematics with the help of Python. Written in the spirit of mathematical exploration and investigation, the book enables students to utilise Python to enrich their understanding of mathematics through: Calculation: performing complex calculations and numerical simulations instantly Visualisation: demonstrating key theorems with graphs, interactive plots and animations Extension: using numerical findings as inspiration for making deeper, more general conjectures. This book is for all learners of mathematics, with the primary audience being mathematics undergraduates who are curious to see how Python can enhance their understanding of core university material. The topics chosen represent a mathematical overview of what students typically study in the first and second years at university, namely analysis, calculus, vector calculus and geometry, differential equations and dynamical systems, linear algebra, abstract algebra and number theory, probability and statistics. As such, it can also serve as a preview of university mathematics for high-school students. The prerequisites for reading the book are a familiarity with standard A-Level mathematics (or equivalent senior high-school curricula) and a willingness to learn programming. For mathematics lecturers and teachers, this book is a useful resource on how Python can be seamlessly incorporated into the mathematics syllabus, assuming only basic knowledge of programming.Table of Contents1 Analysis.- 2 Calculus.- 3 Vector Calculus and Geometry.- 4 Differential Equations and Dynamical Systems.- 5 Linear Algebra.- 6 Abstract Algebra and Number Theory.- 7 Probability.- 8 Statistics.- Appendix A: Python 101.

Read more less

Book SynopsisThis book uses a functional programming language (F#) as a metalanguage to present all concepts and examples, and thus has an operational flavour, enabling practical experiments and exercises. It includes basic concepts such as abstract syntax, interpretation, stack machines, compilation, type checking, garbage collection, and real machine code. Also included are more advanced topics on polymorphic types, type inference using unification, co- and contravariant types, continuations, and backwards code generation with on-the-fly peephole optimization. This second edition includes two new chapters. One describes compilation and type checking of a full functional language, tying together the previous chapters. The other describes how to compile a C subset to real (x86) hardware, as a smooth extension of the previously presented compilers.The examples present several interpreters and compilers for toy languages, including compilers for a small but usable subset of C, abstract machines, a garbage collector, and ML-style polymorphic type inference. Each chapter has exercises. Programming Language Concepts covers practical construction of lexers and parsers, but not regular expressions, automata and grammars, which are well covered already. It discusses the design and technology of Java and C# to strengthen students’ understanding of these widely used languages.Table of ContentsIntroduction.- Interpreters and Compilers.- From Concrete Syntax to Abstract Syntax.- A First-Order Functional Language.- Higher-Order Functions.- Polymorphic Types.- Imperative Languages.- Compiling Micro-C.- Real-World Abstract Machines.- Garbage Collection.- Continuations.- A Locally Optimizing Compiler.- Compiling Micro-SML.- Real Machine Code.- A Crash Course in F#.

Read more less

Book Synopsis

Read more less

Book SynopsisRather than introducing the underpinning theory, the authors approach has been learning-through-doing, which is one that often appeals to programmers. Theory is followed by practical implementation, and in this way the book will cover programming aspects in a self-tutor manner providing an excellent overview.

Read more less

Book Synopsis

Read more less

Book SynopsisDive into the future of programming with this comprehensive guide for Java developers to integrate large language models (LLMs) and Generative AI using the Spring Framework. This book comes at a revolutionary time when AI technology is transforming how we implement solutions in various fields, including natural language processing, content generation, and predictive analytics. With its widespread use in the Java community, the Spring Framework is a logical choice for this integration. By focusing on integrating LLMs and GenAI with Spring, this book bridges a significant gap between cutting-edge AI technologies and traditional Java development practices. The author uses a hands-on approach, guiding you through practical implementation to effectively show how to apply theory in real-world situations. Basic introductions of topicsSpring AI, Spring Framework, and other related AI technologiesevolve into advanced integrations to ensure that you find valuable insights regardless of your starting level. Additionally, this book dedicates sections to security and ethical considerations, addressing the pressing issues associated with AI. With a look at emerging trends and future developments, this book prepares you for what's next, ensuring that you are not just catching up with the current state of technology but are also ready for future advancements. What You Will Learn Master the integration of LLMs and GenAI with the Spring Framework Develop practical skills in developing AI-driven applications using Java Gain insights into handling data, security, and ethical considerations in AI applications Apply strategies for optimizing performance and scalability in AI-enabled applications Prepare for future AI trends and technologiesWho This Book Is ForIntermediate to advanced Java developers who are familiar with the Spring Framework, including concepts such as dependency injection, Spring Boot, and building RESTful services. This foundational knowledge will help developers grasp the more advanced topics of integrating AI technologies with Spring. Prior knowledge of basic AI concepts and machine learning is helpful but not essential as the book covers these topics from the ground up.

Read more less

Book SynopsisIf you thought data structures and algorithms were all just theory, you're missing out on what they can do for your Python code. Learn to use Big O notation to make your code run faster by orders of magnitude. Choose from data structures such as hash tables, trees, and graphs to increase your code's efficiency exponentially. With simple language and clear diagrams, this book makes this complex topic accessible, no matter your background. Every chapter features practice exercises to give you the hands-on information you need to master data structures and algorithms for your day-to-day work. Algorithms and data structures are much more than abstract concepts. Mastering them enables you to write code that runs faster and more efficiently, which is particularly important for today's web and mobile apps. Take a practical approach to data structures and algorithms, with techniques and real-world scenarios that you can use in your daily production code. The Python edition uses Python exclusively for all code examples, exercise, and solutions. Use Big O notation to measure and articulate the efficiency of your code, and modify your algorithm to make it faster. Find out how your choice of arrays, linked lists, and hash tables can dramatically affect the code you write. Use recursion to solve tricky problems and create algorithms that run exponentially faster than the alternatives. Dig into advanced data structures such as binary trees and graphs to help scale specialized applications such as social networks and mapping software. You'll even encounter a single keyword that can give your code a turbo boost. Practice your new skills with exercises in every chapter, along with detailed solutions. Use these techniques today to make your Python code faster and more scalable.

Read more less

Book SynopsisTable of Contents1. Why parallel computing 2. Parallel hardware and parallel software 3. Distributed memory programming with MPI 4. Shared-memory programming with Pthreads 5. Shared-memory programming with OpenMP 6. GPU programming with CUDA 7. Parallel program development 8. Where to go from here

Read more less

Book SynopsisAlan A. A. Donovan is a member of Google's Go team in New York. He holds computer science degrees from Cambridge and MIT and has been programming in industry since 1996. Since 2005, he has worked at Google on infrastructure projects and was the co-designer of its proprietary build system, Blaze. He has built many libraries and tools for static analysis of Go programs, including oracle, godoc -analysis, eg, and gorename. Brian W. Kernighan is a professor in the Computer Science Department at Princeton University. He was a member of technical staff in the Computing Science Research Center at Bell Labs from 1969 until 2000, where he worked on languages and tools for Unix. He is the co-author of several books, including The C Programming Language, Second Edition (Prentice Hall, 1988), and The Practice of Programming (Addison-Wesley, 1999).Table of ContentsPreface xi Chapter 1: Tutorial 1 1.1 Hello, World 1 1.2 Command-Line Arguments 4 1.3 Finding Duplicate Lines 8 1.4 Animated GIFs 13 1.5 Fetching a URL 15 1.6 Fetching URLs Concurrently 17 1.7 A Web Server 19 1.8 Loose Ends 23 Chapter 2: Program Structure 27 2.1 Names 27 2.2 Declarations 28 2.3 Variables 30 2.4 Assignments 36 2.5 Type Declarations 39 2.6 Packages and Files 41 2.7 Scope 45 Chapter 3: Basic Data Types 51 3.1 Integers 51 3.2 Floating-Point Numbers 56 3.3 Complex Numbers 61 3.4 Booleans 63 3.5 Strings 64 3.6 Constants 75 Chapter 4: Composite Types 81 4.1 Arrays 81 4.2 Slices 84 4.3 Maps 93 4.4 Structs 99 4.5 JSON 107 4.6 Text and HTML Templates 113 Chapter 5: Functions 119 5.1 Function Declarations 119 5.2 Recursion 121 5.3 Multiple Return Values 124 5.4 Errors 127 5.5 Function Values 132 5.6 Anonymous Functions 135 5.7 Variadic Functions 142 5.8 Deferred Function Calls 143 5.9 Panic 148 5.10 Recover 151 Chapter 6:. Methods 155 6.1 Method Declarations 155 6.2 Methods with a Pointer Receiver 158 6.3 Composing Types by Struct Embedding 161 6.4 Method Values and Expressions 164 6.5 Example: Bit Vector Type 165 6.6 Encapsulation 168 Chapter 7: Interfaces 171 7.1 Interfaces as Contracts 171 7.2 Interface Types 174 7.3 Interface Satisfaction 175 7.4 Parsing Flags with flag.Value 179 7.5 Interface Values 181 7.6 Sorting with sort.Interface 186 7.7 The http.Handler Interface 191 7.8 The error Interface 196 7.9 Example: Expression Evaluator 197 7.10 Type Assertions 205 7.11 Discriminating Errors with Type Assertions 206 7.12 Querying Behaviors with Interface Type Assertions 208 7.13 Type Switches 210 7.14 Example: Token-Based XML Decoding 213 7.15 A Few Words of Advice 216 Chapter 8: Goroutines and Channels 217 8.1 Goroutines 217 8.2 Example: Concurrent Clock Server 219 8.3 Example: Concu rent Echo Server 222 8.4 Channels 225 8.5 Looping in Parallel 234 8.6 Example: Concurrent Web Crawler 239 8.7 Multiplexing with select 244 8.8 Example: Concurrent Directory Traversal 247 8.9 Cancellation 251 8.10 Example: Chat Server 253 Chapter 9: Concurrency with Shared Variables 257 9.1 Race Conditions 257 9.2 Mutual Exclusion: sync.Mutex 262 9.3 Read/Write Mutexes: sync.RWMutex 266 9.4 Memory Synchronization 267 9.5 Lazy Initialization: sync.Once 268 9.6 The Race Detector 271 9.7 Example: Concurrent Non-Blocking Cache 272 9.8 Goroutines and Threads 280 Chapter 10: Packages and the Go Tool 283 10.1 Introduction 283 10.2 Import Paths 284 10.3 The Package Declaration 285 10.4 Import Declarations 285 10.5 Blank Imports 286 10.6 Packages and Naming 289 10.7 The Go Tool 290 Chapter 11: Testing 301 11.1 The go test Tool 302 11.2 Test Functions 302 11.3 Coverage 318 11.4 Benchmark Functions 321 11.5 Profiling 323 11.6 Example Functions 326 Chapter 12: Reflection 329 12.1 Why Reflection? 329 12.2 reflect.Type and reflect.Value 330 12.3 Display, a Recursive Value Printer 333 12.4 Example: Encoding S-Expressions 338 12.5 Setting Variables with reflect.Value 341 12.6 Example: Decoding S-Expressions 344 12.7 Accessing Struct Field Tags 348 12.8 Displaying the Methods of a Type 351 12.9 A Word of Caution 352 Chapter 13: Low-Level Programming 353 13.1 unsafe.Sizeof, Alignof, and Offsetof 354 13.2 unsafe.Pointer 356 13.3 Example: Deep Equivalence 358 13.4 Calling C Code with cgo 361 13.5 Another Word of Caution 366 Index 367

Read more less

Book SynopsisDonis Marshall has more than twenty years of experience in designing and building enterprise software with Microsoft technologies for leading companies in multiple industries. An endorsed trainer for Microsoft Global Learning Services, he has trained Microsoft developers and engineers for many years. His Microsoft Press books include Solid Code and Programming Microsoft Visual C#. Table of ContentsChapter 1: Introduction to Rust 1 Introduction 1 Features 4 Rust Terminology 6 Tools 7 Summary 8 Chapter 2: Getting Started 9 Preliminaries 9 Rust and Windows 10 Installing Rust 10 Advanced Rustup 11 “Hello, World” 11 Compile and Run 12 Cargo 13 Library 15 Comments 17 Published Crates 20 Main Function 21 Command-Line Arguments 22 Summary 23 Chapter 3: Variables 25 Terminology 25 Variables 26 Primitives 26 Integer Types 27 Overflow 28 Notations 29 Floating Point Types 30 Floating Point Constants 30 Infinity 31 NaN 31 Numeric Ranges 32 Casting 33 Boolean Types 34 Char 34 Pointers 35 Operators 37 Summary 40 Chapter 4: Strings 41 Str 41 String 42 Length 43 Extending a String 44 Capacity 45 Accessing a String Value 46 String Characters 48 Deref Coercion 48 Formatted String 49 Helpful Functions 49 Summary 52 Chapter 5: Console 53 Print 53 Positional Arguments 54 Variable Arguments 55 Named Arguments 55 Padding, Alignment, and Precision 56 Base 58 Developer Facing 59 Write! Macro 60 Display Trait 60 Debug Trait 62 Format! Macro 63 Console Read and Write 63 Summary 64 Chapter 6: Control Flow 65 The if Expression 65 The while Expression 68 The for Expression 70 The loop Expression 73 The Iterator Trait 76 Summary 78 Chapter 7: Collections 79 Arrays 79 Vectors 86 HashMap 91 Summary 95 Chapter 8: Ownership 97 Stack and Heap Memory 98 Shallow versus Deep Copy 98 Car Analogy 99 Move Semantics 99 Borrow 101 Copy Semantics 101 Clone Trait 102 Copy Trait 103 Clone Trait 104 Summary 105 Chapter 9: Lifetimes 107 Introduction to Lifetimes 108 Function Headers and Lifetimes 109 Lifetime Annotation 111 Lifetime Elision 112 Complex Lifetimes 113 Sharing a Lifetime 114 Static Lifetimes 115 Structs and Lifetimes 116 Methods and Lifetimes 116 Subtyping Lifetimes 118 Anonymous Lifetimes 120 Generics and Lifetimes 121 Summary 121 Chapter 10: References 123 Declaration 124 Borrowing 124 Dereferencing 125 Comparing References 126 Reference Notation 127 Reference to Reference 128 Mutability 129 Limits to Multiple Borrowers 130 Summary 131 Chapter 11: Functions 133 Function Definition 133 Parameters 134 Function Return 136 Const Functions 138 Nested Functions 139 Function Pointers 140 Function Aliases 142 Summary 143 Chapter 12: Error Handling 145 Handling Error Handling 145 The Result Enum 146 The Option Enum 147 Panics 148 Unwrapping 154 Match Pattern for Result and Option 156 Map 158 Rich Errors 160 Custom Errors 161 Summary 163 Chapter 13: Structures 165 Alternate Initialization 167 Move Semantics 169 Mutability 170 Methods 170 Self 172 Associated Functions 173 Impl Blocks 174 Operator Overloading 175 Tuple Struct 179 Summary 180 Chapter 14: Generics 181 Generic Functions 182 Bounds 186 The where Clause 188 Structs 190 Associated Functions 194 Enums 195 Generic Traits 197 Explicit Specialization 200 Summary 205 Chapter 15: Patterns 207 Let Statement 207 Wildcards 208 Complex Patterns 209 Ownership 210 Irrefutable 212 Ranges 213 Multiple Patterns 214 Control Flow 215 Structs 216 Functions 219 Match Expressions 220 Match Guards 224 Summary 227 Chapter 16: Closures 229 “Hello, World” 229 Closure Syntax 230 Closed Over 231 Closures as Function Arguments 233 Closures as Function Return Values 234 Implementation of Closures 235 Matrix Example 242 Summary 244 Chapter 17: Traits 245 Trait Definition 245 Default Functions 248 Marker Trait 249 Associated Functions 249 Associated Types 251 Extension Methods 253 Fully Qualified Syntax 254 Supertraits 257 Static Dispatch 260 Dynamic Dispatch 262 Enums and Traits 263 Summary 265 Chapter 18: Threads 1 267 Synchronous Function Calls 268 Threads 269 The Thread Type 273 Processor Time 274 Builder 275 Communicating Sequential Process 276 Asynchronous Channel 277 Synchronous Channel 279 Rendezvous Channel 280 The try Methods 281 Store Example 286 Summary 290 Chapter 19: Threads 2 291 Mutex 291 Nonscoped Mutex 294 Mutex Poisoning 296 Reader-Writer Lock 297 Condition Variables 299 Atomic Operations 301 Summary 305 Chapter 20: Memory 307 Stacks 307 Static Values 309 The Heap 310 Interior Mutability 312 RefCell 316 OnceCell 318 Summary 319 Chapter 21: Macros 321 Tokens 322 Declarative Macros 323 Repetition 325 Multiple Macro Matchers 327 Procedural Macros 328 Derive Macros 329 Attribute Macros 332 Function-Like Macros 334 Summary 335 Chapter 22: Interoperability 337 Foreign Function Interface 337 Basic Example 339 Libc Crate 341 Structs 342 Bindgen 346 C Calling Rust Functions 347 Cbindgen 348 Summary 351 Chapter 23: Modules 353 Module Items 354 Module Files 358 The path Attribute 360 Functions and Modules 361 The crate, super, and self Keywords 362 Legacy Model 363 Summary 365 Index 367

Read more less

Book SynopsisMichael Hartl created the legendary Ruby on Rails Tutorial that helped jumpstart thousands of web development careers. A cofounder and principal author at Learn Enough, Hartl previously earned a Ph.D. in physics at the California Institute of Technology (Caltech), where he received a Lifetime Achievement Award for Excellence in Teaching. He is also an alumnus Harvard University and the world-renowned Y Combinator entrepreneur program.Trade Review"Just started the #100DaysOfCode journey. Today marks day 1. I have completed @mhartl's great Ruby tutorial at @LearnEnough and am looking forward to starting on Ruby on Rails from tomorrow. Onwards and upwards."--Optimize Prime (@_optimize), Twitter post "Ruby and Sinatra and Heroku, oh my! Almost done with this live web application. It may be a simple palindrome app, but it's also simply exciting! #100DaysOfCode #ruby @LearnEnough #ABC #AlwaysBeCoding #sinatra #heroku"--Tonia Del Priore (@toninjaa), Twitter post; Software Engineer for a FinTech Startup for 3+ years "I have nothing but fantastic things to say about @LearnEnough courses. I am just about finished with the #javascript course. I must say, the videos are mandatory because @mhartl will play the novice and share in the joy of having something you wrote actually work!"--Claudia Vizena "I must say, this Learn Enough series is a masterpiece of education. Thank you for this incredible work!"--Michael King "I want to thank you for the amazing job you have done with the tutorials. They are likely the best tutorials I have ever read."--Pedro IatzkyTable of ContentsPreface xiiiAcknowledgments xviiAbout the Author xix Chapter 1: Hello, World! 11.1 Introduction to Python 61.2 Python in a REPL 111.3 Python in a File 131.4 Python in a Shell Script 161.5 Python in a Web Browser 18 Chapter 2: Strings 352.1 String Basics 352.2 Concatenation and Interpolation 382.3 Printing 442.4 Length, Booleans, and Control Flow 462.5 Methods 562.6 String Iteration 62 Chapter 3: Lists 693.1 Splitting 693.2 List Access 713.3 List Slicing 743.4 More List Techniques 773.5 List Iteration 833.6 Tuples and Sets 86 Chapter 4: Other Native Objects 914.1 Math 914.2 Times and Datetimes 974.3 Regular Expressions 1034.4 Dictionaries 1094.5 Application: Unique Words 115 Chapter 5: Functions and Iterators 1215.1 Function Definitions 1215.2 Functions in a File 1305.3 Iterators 138 Chapter 6: Functional Programming 1496.1 List Comprehensions 1506.2 List Comprehensions with Conditions 1566.3 Dictionary Comprehensions 1596.4 Generator and Set Comprehensions 1636.5 Other Functional Techniques 165 Chapter 7: Objects and Classes 1697.1 Defining Classes 1697.2 Custom Iterators 1767.3 Inheritance 1797.4 Derived Classes 183 Chapter 8: Testing and Test-Driven Development 1918.1 Package Setup 1928.2 Initial Test Coverage 1978.3 Red 2098.4 Green 2148.5 Refactor 220 Chapter 9: Shell Scripts 2319.1 Reading from Files 2319.2 Reading from URLs 2409.3 DOM Manipulation at the Command Line 245 Chapter 10: A Live Web Application 25510.1 Setup 25610.2 Site Pages 26310.3 Layouts 27110.4 Template Engine 28010.5 Palindrome Detector 29310.6 Conclusion 316 Chapter 11: Data Science 31911.1 Data Science Setup 32011.2 Numerical Computations with NumPy 32711.3 Data Visualization with Matplotlib 33811.4 Introduction to Data Analysis with pandas 35311.5 pandas Example: Nobel Laureates 36111.6 pandas Example: Titanic 37711.7 Machine Learning with scikit-learn 38611.8 Further Resources and Conclusion 403 Index 405

Read more less

Book SynopsisDavid Mertz has been a member of the Python community for 25 years. He has taught Python to scientists, developers coming from other languages, and to programming neophytes. He was a director of the Python Software Foundation (PSF) for six years and continues to serve on, or chair, a variety of PSF working groups. David is the author of several technical books and has given keynote addresses at numerous international programming conferences.Trade Review"You'll not just be aspiring to be an expert anymore after practicing through Better Python Code: A Guide for Aspiring Experts, you'll be one of them! Learn from David Mertz, who's been making experts through his writing and training for the past 20 years."--Iqbal Abdullah, past Chair, PyCon Asia Pacific, and past board member, PyCon Japan "In Better Python Code: A Guide for Aspiring Experts, David Mertz serves up bite-sized chapters of Pythonic wisdom in this must-have addition to any serious Python programmer's collection. This book helps bridge the gap from beginner to advanced Python user, but even the most seasoned Python programmer can up their game with Mertz's insight into the ins and outs of Python."--Katrina Riehl, President, NumFOCUS "What separates ordinary coders from Python experts? It's more than just knowing best practices--it's understanding the benefits and pitfalls of the many aspects of Python, and knowing when and why to choose one approach over another. In this book David draws on his more than 20 years of involvement in the Python ecosystem and his experience as a Python author to make sure that the readers understand both what to do and why in a wide variety of scenarios."--Naomi Ceder, past Chair, Python Software Foundation "Like a Pythonic BBC, David Mertz has been informing, entertaining, and educating the Python world for over a quarter of a century, and he continues to do so here in his own pleasantly readable style."--Steve Holden, past Chair, Python Software Foundation "Being expert means someone with a lot of experience. David's latest book provides some important but common problems that folks generally learn only after spending years of doing and fixing. I think this book will provide a much quicker way to gather those important bits and help many folks across the world to become better."--Kushal Das, CPython Core Developer and Director, Python Software Foundation "This book is for everyone: from beginners, who want to avoid hard-to-find bugs, all the way to experts looking to write more efficient code. David Mertz has compiled a great set of useful idioms that will make your life as a programmer easier and your users happier."--Marc-André Lemburg, past Chair, EuroPython, and past Director, Python Software FoundationTable of ContentsForeword xviiPreface xixAcknowledgments xxvAbout the Author xxvii Introduction 1 Chapter 1: Looping Over the Wrong Things 31.1 (Rarely) Generate a List for Iteration 31.2 Use enumerate() Instead of Looping Over an Index 61.3 Don't Iterate Over dict.keys() When You Want dict.items() 81.4 Mutating an Object During Iteration 91.5 for Loops Are More Idiomatic Than while Loops 121.6 The Walrus Operator for "Loop-and-a-Half" Blocks 131.7 zip() Simplifies Using Multiple Iterables 151.8 zip(strict=True) and itertools.zip_longest() 171.9 Wrapping Up 20 Chapter 2: Confusing Equality with Identity 212.1 Late Binding of Closures 212.2 Overchecking for Boolean Values 252.3 Comparing x == None 282.4 Misunderstanding Mutable Default Arguments 292.5 Copies versus References to Mutable Objects 332.6 Confusing is with == (in the Presence of Interning) 352.7 Wrapping Up 37 Chapter 3: A Grab Bag of Python Gotchas 393.1 Naming Things 393.2 Quadratic Behavior of Naive String Concatenation 523.3 Use a Context Manager to Open a File 563.4 Optional Argument key to .sort() and sorted() 593.5 Use dict.get() for Uncertain Keys 623.6 Wrapping Up 64 Chapter 4: Advanced Python Usage 674.1 Comparing type(x) == type(y) 674.2 Naming Things (Revisited) 714.3 Keep Less-Used Features in Mind 794.4 Type Annotations Are Not Runtime Types 984.5 Wrapping Up 105 Chapter 5: Just Because You Can, It Doesn't Mean You Should... 1075.1 Metaclasses 1075.2 Monkeypatching 1125.3 Getters and Setters 1155.4 It's Easier to Ask for Forgiveness Than Permission 1185.5 Structural Pattern Matching 1215.6 Regular Expressions and Catastrophic Backtracking 1235.7 Wrapping Up 126 Chapter 6: Picking the Right Data Structure 1296.1 collections.defaultdict 1296.2 collections.Counter 1326.3 collections.deque 1356.4 collections.ChainMap 1386.5 Dataclasses and Namedtuples 1416.6 Efficient Concrete Sequences 1466.7 Wrapping Up 150 Chapter 7: Misusing Data Structures 1537.1 Quadratic Behavior of Repeated List Search 1537.2 Deleting or Adding Elements to the Middle of a List 1577.3 Strings Are Iterables of Strings 1637.4 (Often) Use enum Rather Than CONSTANT 1667.5 Learn Less Common Dictionary Methods 1697.6 JSON Does Not Round-Trip Cleanly to Python 1747.7 Rolling Your Own Data Structures 1787.8 Wrapping Up 187 Chapter 8: Security 1898.1 Kinds of Randomness 1908.2 Putting Passwords or Other Secrets in "Secure" Source Code 1958.3 "Rolling Your Own" Security Mechanisms 1988.4 Use SSL/TLS for Microservices 2018.5 Using the Third-Party requests Library 2058.6 SQL Injection Attacks When Not Using DB-API 2088.7 Don’t Use assert to Check Safety Assumptions 2128.8 Wrapping Up 215 Chapter 9: Numeric Computation in Python 2179.1 Understanding IEEE-754 Floating Point Numbers 2179.2 Numeric Datatypes 2289.3 Wrapping Up 239 Appendix: Topics for Other Books 241A.1 Test-Driven Development 241A.2 Concurrency 242A.3 Packaging 243A.4 Type Checking 243A.5 Numeric and Dataframe Libraries 244 Index 245

Read more less

Book SynopsisAbout our authors Paul J. Deitel, CEO and Chief Technical Officer of Deitel & Associates, Inc., is an MIT graduate with 43 years in computing. He is one of the world's most experienced programming-languages trainers, having taught professional courses to software developers since 1992. He has delivered hundreds of programming courses to academic, industry, government and military clients of Deitel & Associates, Inc. internationally, including UCLA, SLB (formerly Schlumberger), Cisco, IBM, Siemens, Sun Microsystems (now Oracle), Dell, Fidelity, NASA at the Kennedy Space Center, the National Severe Storm Laboratory, White Sands Missile Range, Rogue Wave Software, Boeing, Puma, iRobot and many more. Dr. Harvey M. Deitel, Chairman and Chief Strategy Officer of Deitel & Associates, Inc., has 62 years of experience in computing. Dr. Deitel earned B.S. and M.S. degrees in Electrical Engineering from MIT and a Ph.D. in Mathematics from Bosto

Read more less

Book SynopsisTurn the corner from “Haskell student” to “Haskell developer.” Haskell in Depth explores the important language features and programming skills you’ll need to build production-quality software using Haskell. And along the way, you’ll pick up some interesting insights into why Haskell looks and works the way it does. Get ready to go deep! Haskell in Depth is the perfect second book on Haskell. After a quick refresher on Haskell basics, this hands-on guide dives into examples and application scenarios designed to teach how Haskell works and how to apply it correctly. You’ll learn about managing projects with Cabal and Stack, tackle error-handling and testing, and package programs and libraries for production deployment. Key Features · Organizing your projects with Cabal and Stack · Testing and profiling · Working with data · Building web services and networking apps · Using the sophisticated libraries like lens, vinyl, and servant Written for developers familiar with Haskell basics. About the technology As software becomes more complex, it’s essential to program efficiently using tools and techniques that guarantee your applications will run correctly, grow easily, and last a long time. Haskell is a functional programming language that blends a mathematically-rigorous approach to software design with a tested ecosystem of tools and libraries you can use to build deployable applications. Since 2008, Vitaly Bragilevsky has been teaching Haskell and functional programming to undergraduate students at the Southern Federal University located in Rostov-on-Don, Russia. He is a member of the Haskell 2020 Committee, and has worked on the source code of the Glasgow Haskell Compiler (GHC) and the Idris compiler, both of which are implemented in Haskell.

Read more less

Book SynopsisAs a software engineer, you’ll encounter countless programming challenges that initially seem confusing, difficult, or even impossible. Don’t despair! Many of these “new” problems already have well-established solutions. Advanced Algorithms and Data Structures teaches you powerful approaches to a wide range of tricky coding challenges that you can adapt and apply to your own applications. Providing a balanced blend of classic, advanced, and new algorithms, this practical guide upgrades your programming toolbox with new perspectives and hands-on techniques. about the technology Data structures and algorithms are the foundations for how programs store and process information. Choosing the optimal algorithms ensures that your programs are fast, efficient, and reliable. about the book Algorithms and Data Structures in Action expands on the basic algorithms you already know to give you a better selection of solutions to different programming problems. In it, you’ll discover techniques for improving priority queues, efficient caching, clustering data, and more. Each example is fully illustrated with graphics, language agnostic pseudo-code, and code samples in various languages. When you’re done, you will be able to implement advanced and little-known algorithms to deliver better performance from your code. what's inside Improving on basic data structures Efficient caching Nearest neighbour search, including k-d trees and S-trees Full ‘pseudo-code’ and samples in multiple languages about the readerFor programmers with basic or intermediate skills. Written in a language-agnostic manner, no specific language knowledge is required. about the author Marcello La Rocca is a research scientist and a full-stack engineer focused on optimization algorithms, genetic algorithms, machine learning and quantum computing. He has contributed to large-scale web applications at companies like Twitter and Microsoft, has undertaken applied research in both academia and industry, and authored the Neatsort adaptive sorting algorithm.

Read more less

Book Synopsis

Read more less

Book SynopsisLearn Quantum Computing with Python and Q# demystifies quantum computing. Using Python and the new quantum programming language Q#, you’ll learn QC fundamentals as you apply quantum programming techniques to real-world examples including cryptography and chemical analysis. Learn Quantum Computing with Python and Q# builds your understanding of quantum computers, using Microsoft’s Quantum Development Kit to abstract away the mathematical complexities. You’ll learn QC basics as you create your own quantum simulator in Python, then move on to using the QDK and the new Q# language for writing and running algorithms very different to those found in classical computing. Key Features · The underlying mechanics of how quantum computers work · How to simulate qubits in Python · Q# and the Microsoft Quantum Developer Kit · How to apply quantum algorithms to real-world examples For readers with basic programming skills and some experience of linear algebra, calculus and complex numbers. About the technology Quantum computing is the next step in computing power and scalability, with the potential to impact everything from data science to information security. Using qubits, the fundamental unit of quantum information, quantum computers can solve problems beyond the scale of classical computing. Software packages like Microsoft's Quantum Development Kit and the Q# language are now emerging to give programmers a quick path to exploring quantum development for the first time. Christopher Granade completed his PhD in physics (quantum information) at the University of Waterloo’s Institute for Quantum Computing, and now works in the Quantum Architectures and Computation (QuArC) group at Microsoft. He works in developing the standard libraries for Q# and is an expert in the statistical characterization of quantum devices from classical data. Previously, Christopher helped Scott Aaronson prepare lectures into his recent book, Quantum Computing Since Democritus. Sarah Kaiser completed her PhD in physics (quantum information) at the University of Waterloo’s Institute for Quantum Computing. She has spent much of her career developing new quantum hardware in the lab, from satellites to hacking quantum cryptography hardware. Communicating what is so exciting about quantum is her passion, and she loves finding new demos and tools to help enable the quantum community to grow. When not at the keyboard, she loves kayaking and writing books about engineering for kids.

Read more less

Book SynopsisSharpen your coding skills by exploring established computer science problems! Classic Computer Science Problems in Java challenges you with time-tested scenarios and algorithms. You’ll work through a series of exercises based in computer science fundamentals that are designed to improve your software development abilities, improve your understanding of artificial intelligence, and even prepare you to ace an interview. Classic Computer Science Problems in Java will teach you techniques to solve common-but-tricky programming issues. You’ll explore foundational coding methods, fundamental algorithms, and artificial intelligence topics, all through code-centric Java tutorials and computer science exercises. As you work through examples in search, clustering, graphs, and more, you'll remember important things you've forgotten and discover classic solutions to your "new" problems! Key Features · Recursion, memorization, bit manipulation · Search algorithms · Constraint-satisfaction problems · Graph algorithms · K-means clustering For intermediate Java programmers. About the technology In any computer science classroom you’ll find a set of tried-and-true algorithms, techniques, and coding exercises. These techniques have stood the test of time as some of the best ways to solve problems when writing code, and expanding your Java skill set with these classic computer science methods will make you a better Java programmer. David Kopec is an assistant professor of computer science and innovation at Champlain College in Burlington, Vermont. He is the author of Dart for Absolute Beginners (Apress, 2014), Classic Computer Science Problems in Swift (Manning, 2018), and Classic Computer Science Problems in Python (Manning, 2019).

Read more less

Book SynopsisMarco Peixeiro is a renowned data-science educator known for demystifying complex forecasting techniques. With years developing open-source libraries at Nixtla, Marco brings clarity, practicality, and enthusiasm to every page. He distills cutting-edge research into step-by-step guidance that helps readers deliver accurate forecasts quickly.

Read more less

Book SynopsisPython is a powerful programming language that's easy to learn and fun to play with. But once you've gotten a handle on the basics, what's next? Python Playground, 2nd Edition is a collection of imaginative programming projects that will inspire readers to use Python for making art and music, simulating real-world phenomena, and interacting with hardware. This second edition is fully updated to be even more user friendly and features five brand-new projects, like transforming a Raspberry Pi Pico into a playable instrument, creating an IoT system to monitor your garden, and using machine learning to develop a speech-recognition system. Programming shouldn't be a chore, so have some geeky fun with Python Playground, 2nd Edition!Trade Review"Python Playground has excellent projects for the science-minded programmer, the programming-minded science enthusiast, and everyone in between."—Al Sweigart, author of Automate the Boring Stuff with PythonReviews of the first edition:"If you want to become adept at doing clever things with Python, I doubt you'll find a better group of projects or more useful help for understanding how the language works."—Network World "This is a book that belongs in every Python programmer's library."—Full Circle Magazine"Packed with interesting projects."—iProgrammer"Python Playground targets programmers who want to further improve their skills and knowledge of the language. The book does a good job of explaining all relevant details and makes sure that readers get a clear picture of what is going on."—InfoQ"As an intermediate coder and educator, I appreciate how this book pushes boundaries with Python, inviting those who enjoy a rigorous coding puzzle. It's a solid pick for developers and coders looking to level up."—Kelly Schuster-Paredes, co-host of The Teaching Python podcast

Read more less

Book SynopsisTake a problem-solution approach for programming enterprise Java or Java EE applications and microservices for cloud-based solutions, enterprise database applications, and even small business web applications. Java EE to Jakarta EE 10 Recipes provides effective, practical, and proven code snippets that you can immediately use to accomplish just about any task that you may encounter. You can feel confident using the reliable solutions that are demonstrated in this book in your personal or corporate environment. Java EE was made open source under the Eclipse Foundation, and Jakarta EE is the new name for what used to be termed the Java Platform, Enterprise Edition. This book helps you rejuvenate your Java expertise and put the platform''s latest capabilities to use for quickly developing robust applications. If you are new to Jakarta EE, this book will help you learn the features of the platform and benefit from one of the most widely used anTable of ContentsRevision Notes from AuthorBased on the book preview, below is the list of changes/updates I see relevant for the next revisions of this book - Jakarta EE 10 Recipes. ----------------------------------Introduction: Adding following details for Jakarta EE 9, 9.1 and 10 releases like timelines and theme. Updating instructions for enabling Jakarta EE support using NetBeans IDE Adding instructions for using the following IDE for building Jakarta EE applications. Eclipse IDE Visual Studio Code Providing instructions for installing the following build tools for Jakarta EE Maven Gradle All Chapters: Rename to chapter title Servlets and Jakarta Server Pages Updating terminologies as below: JavaServer Pages(JSP) to Jakarta Server Pages JavaServer Faces(JSF) to Jakarta Faces, JavaMail to Jakarta Mail … Reworking and verifying the code examples by performing the following modifications Updating import statements in all code samples from javax.* to jakarta.*. Updating code to make use of the latest Java 11 features Updating instructions for enabling Jakarta EE support using NetBeans IDE Adding instructions for using the following IDE as well for building Jakarta EE applications. Eclipse IDE Visual Studio Code Ensuring the code can be executed in the latest releases of the following servers Open Liberty, WildFly and GlassFish servers as are the flag bearers for Jakarta EE compliance. Also verifying the code with other servers based on their availability with support for latest functionality like Payara or Apache TomEE or Oracle Weblogic and provide any specific instructions in case applicable. Note: As I would dig deeper into the content will be able to suggest more pointsChapter 1: Servlets and JavaServer Pages Rename to chapter title Servlets 1-8 (Adding content about - Improving performance with server push) Adding a recipe for adding a user authentication to Servlets. Adding a recipe for defining servlet behaviour based on user authorization Adding more recipes for the following topics session tracking and Handling cookies HTTP Session handling Servlet Filters / URL Redirections . Move JSP related recipes to a separate chapter New Chapter 2: Creating a New Chapter on Jakarta Server Pages Adding recipes for the following topics Handling file uploads Add recipe for Implementing Internationalization Managed Bean 2.0 Chapter 2: JavaServer Faces Fundamentals Rename to chapter title Jakarta Faces Fundamentals Updating code as per Jakarta Faces 4.0 specification Adding recipes for the following topics Externalizing strings using resource bundles Chapter 3: Advanced JavaServer Faces Rename to chapter title Advanced Jakarta Faces Chapter 4: Eclipse Krazo renaming it to Jakarta MVC and updating it with content for Jakarta MVC. Chapter 5: JDBC with Jakarta EE Adding a Chapter with recipes on Jakarta Transactions Chapter 6: Object-Relational Mapping Adding sections about migrating from Hibernate ORM 5.5 to Jakarta Persistence. Chapter 7: Jakarta NoSQL Add recipes related to working with graph databases (like neo4j). Chapter 8: Enterprise JavaBeans Updating recipes as Jakarta Enterprise Beans 4.0 specifications. Chapter 9: Java Persistence Query Language Rename chapter title to Jakarta Persistence Query Language Chapter 10: Bean Validation Updating recipes as per Jakarta Bean validation 3.0 standard Adding recipes about Migration from Hibernate Validator Chapter 11: Contexts and Dependency Injection Updates based on the latest CDI support Adding recipes related to Interceptor bindings Decorators Firing Events Chapter 12: Java Message Service Rename to Jakarta Messaging Updating recipes as per Jakarta Messaging 3.0Chapter 13: RESTful Web ServicesAdding a Chapter on migrating from Spring would also make sense as the upcoming release of Spring Framework 6 will align with Jakarta EE starting Q3 2021Add recipes for Handling various status codes in HTTP responses. Chapter 14: WebSockets and JSONContent on WebSockets would be better suited after chapter Restructuring sections on Web Sockets from Chapter 14 to Chapter 2 after HTTP/2 Server Push in Servlets changes Adding a chapter on Jakarta Concurrency Chapter 15: SecurityRename to Jakarta SecurityAdding recipes for The authentication mechanism for Client-Cert and Digest Support for OpenID, OAuth and JWT Chapter 16: Concurrency and Batch Updating recipes as per Jakarta Concurrency 3.0 Chapter 17: Deploying to Containers Adding topics related to running microservices targeted at smaller runtimes as per Jakarta Core Profile standard 1. Servlets and Java Server Pages2. JavaServer Faces Fundamentals3. Advanced JavaServer Faces4. Eclipse Krazo5. JDBC With Jakarta EE6. Object-Relational Mapping7. Jakarta NoSQL8. Enterprise JavaBeans9. Java Persistence Query Language10. Bean Validation11. Contexts and Dependency Injection12. Java Message Service13. RESTful Web Services14. WebSockets and JSON15. Security16. Concurrency and Batch17. Deploying to Containers

Read more less

Book SynopsisUpdated for the latest React release, the second edition of this hands-on guide shows you how to build React components and organize them into maintainable large-scale apps. If you're familiar with JavaScript syntax, you're ready to get started.

Read more less

Book SynopsisSanjay Madhav is a senior lecturer at the University of Southern California, where he teaches several programming and video game programming courses. He has taught at USC since 2008. Prior to joining USC, Sanjay worked as a programmer for several video game developers, including Electronic Arts, Neversoft, and Pandemic Studios. His credited games include Medal of Honor: Pacific Assault, Tony Hawk's Project 8, Lord of the Rings: Conquest, and The Saboteur. Sanjay is also the author of Game Programming Algorithms and Techniques and co-author of Multiplayer Game Programming. He has a B.S. and an M.S. in computer science and is pursuing a Ph.D. in computer science, all from USC. Table of ContentsPreface Chapter 1 Game Programming Overview Chapter 2 Game Objects and 2D Graphics Chapter 3 Vectors and Basic Physics Chapter 4 Artificial Intelligence Chapter 5 OpenGL Chapter 6 3D Graphics Chapter 7 Audio Chapter 8 Input Systems Chapter 9 Cameras Chapter 10 Collision Detection Chapter 11 User Interfaces Chapter 12 Skeletal Animation Chapter 13 Intermediate Graphics Chapter 14 Level Files and Binary Data Appendix A Intermediate C++ Review Index

Read more less

Book SynopsisImagine writing Java code that reads like the problem statement, code that's highly expressive, concise, easy to read and modify, and has reduced complexity. With the functional programming capabilities in Java, that's not a fantasy. This book will guide you from the familiar imperative style through the practical aspects of functional programming, using plenty of examples. Apply the techniques you learn to turn highly complex imperative code into elegant and easy-to-understand functional-style code. Updated to the latest version of Java, this edition has four new chapters on error handling, refactoring to functional style, transforming data, and idioms of functional programming. Don't struggle with the limitations of the imperative style; instead learn to combine object-oriented programming with the functional style to reduce the accidental complexity. Harness the functional programming capabilities of Java to create applications where the program reveals its intentions and your team can quickly understand and modify code to align with changing business requirements. Unlock the power of lambda expressions and the Streams API to turn the oft-written spaghetti code into highly concise, expressive, elegant, and maintainable code. See how Streams make the arduous task of parallelizing code as easy as flipping a switch when superior speed is necessary. Apply design patterns built around lambda expressions, safely manage resource allocations, use memoization, and learn to transform data into different forms, all while honoring immutability, and providing thread safety to leverage lazy evaluation for efficiency and parallel execution for performance. Move beyond the basics, explore the idioms for writing functional programs. Learn to think functionally by refactoring legacy code into the functional style. And, if your code runs aground due to failures, learn to properly handle errors the functional way. Don't drown in theory; instead learn the practical functional programming techniques to create superior Java code. What You Need: Java version 8 or newer.

Read more less

Book SynopsisTest applications, packages, and libraries large and small with pytest, Python's most powerful testing framework. pytest helps you write tests quickly and keep them readable and maintainable. In this fully revised edition, explore pytest's superpowers - simple asserts, fixtures, parametrization, markers, and plugins - while creating simple tests and test suites against a small database application. Using a robust yet simple fixture model, it's just as easy to write small tests with pytest as it is to scale up to complex functional testing. This book shows you how. pytest is undeniably the best choice for testing Python projects. It's a full-featured, flexible, and extensible testing framework. pytest's fixture model allows you to share test data and setup procedures across multiple layers of tests. The pytest framework gives you powerful features such as assert rewriting, parametrization, markers, plugins, parallel test execution, and clear test failure reporting - with no boilerplate code. With simple step-by-step instructions and sample code, this book gets you up to speed quickly on this easy-to-learn yet powerful tool. Write short, maintainable tests that elegantly express what you're testing. Speed up test times by distributing tests across multiple processors and running tests in parallel. Use Python's builtin assert statements instead of awkward assert helper functions to make your tests more readable. Move setup code out of tests and into fixtures to separate setup failures from test failures. Test error conditions and corner cases with expected exception testing, and use one test to run many test cases with parameterized testing. Extend pytest with plugins, connect it to continuous integration systems, and use it in tandem with tox, mock, coverage, and even existing unittest tests. Write simple, maintainable tests quickly with pytest. What You Need: The examples in this book were written using Python 3.9 and pytest 6. pytest 6 supports Python 3.5 and above.

Read more less

Book SynopsisRust is a new systems programming language that gives you the low-level power of C with the elegance and ease of languages like Ruby and Python. Rust is thread safe, enabling "fearless concurrency". Rust in Action introduces the Rust programming language by exploring numerous systems programming concepts and techniques. You'll be learning Rust by delving into how computers work under the hood. You'll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You'll also discover parallel and concurrent programming. · Concurrent and parallel programming Sharing resources with locks or atomic operations Avoiding programming with global state Message passing inside your applications Memory management and garbage collection Readers need intermediate programming skills and familiarity with general computer science concepts, the command line, and networking.

Read more less

Book SynopsisThis is the book for Gophers who want to learn how to build distributed systems. You know the basics of Go and are eager to put your knowledge to work. Build distributed services that are highly available, resilient, and scalable. This book is just what you need to apply Go to real-world situations. Level up your engineering skills today. Take your Go skills to the next level by learning how to design, develop, and deploy a distributed service. Start from the bare essentials of storage handling, then work your way through networking a client and server, and finally to distributing server instances, deployment, and testing. All this will make coding in your day job or side projects easier, faster, and more fun. Create your own distributed services and contribute to open source projects. Build networked, secure clients and servers with gRPC. Gain insights into your systems and debug issues with observable services instrumented with metrics, logs, and traces. Operate your own Certificate Authority to authenticate internal web services with TLS. Automatically handle when nodes are added or removed to your cluster with service discovery. Coordinate distributed systems with replicated state machines powered by the Raft consensus algorithm. Lay out your applications and libraries to be modular and easy to maintain. Write CLIs to configure and run your applications. Run your distributed system locally and deploy to the cloud with Kubernetes. Test and benchmark your applications to ensure they're correct and fast. Dive into writing Go and join the hundreds of thousands who are using it to build software for the real world. What You Need: Go 1.13+ and Kubernetes 1.16+

Read more less