liveBookmanning.com

What you will learn in Julia as a Second Language

General purpose programming with a taste of data science

by Erik Engheim

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• arrayAn array is an ordered collection of elements that can have any Julia-supported element type and can be organized in one or more dimensions.
• JuliaJulia is a high-level programming language designed for technical and scientific computing with both dynamic-language expressiveness and high performance.
• parameterized typeA parametric type is a type definition whose structure or behavior is specialized by one or more type parameters.
• dynamic typingDynamic typing is a type system property in which type checking is performed primarily at runtime rather than before execution.
• loopA loop is a programming construct that repeatedly executes code while a specified condition remains true or until a termination condition is met.
• environmentA package environment is a configuration context that records package availability, versions, dependencies, and source locations for a Julia session.
• setA set is a collection that stores distinct elements without relying on positional order.
• genericsA parametric method is a method whose signature includes type parameters that constrain or relate its argument types.
• packageA package is a distributable unit of software containing reusable code and metadata that can be installed and managed by a package manager.
• data conversionNumber conversion is the transformation of a value from one numeric type to another related numeric type.
• abstract typeAn abstract type is a type that defines a conceptual interface or classification without directly representing concrete instances.
• conditional logicConditional execution is the execution of code only when a specified logical condition holds.
• functionA function definition is a language construct that declares a function's name, arguments, and executable body.
• multiple dispatchMultiple dispatch is a method-selection mechanism that chooses an operation implementation based on the types of all dispatched arguments.
• MapA dictionary is a mutable associative collection that maps keys to values, with each dictionary specifying or inferring the types of its keys and values.
• interfaceAn interface is a defined set of operations and behavioral expectations through which software components interact independently of their implementations.
• methodA method is a function implementation associated with a particular argument-type signature and selected when a call matches that signature.
• structThe struct keyword is Julia syntax for defining a composite type.
• linked listA linked list is a collection data structure whose elements are connected through links rather than stored in one contiguous indexed sequence.
• map!map! is a Julia mutating mapping function that writes transformed elements into a destination array.
• substitution cipherA substitution cipher is a cryptographic method that replaces each symbol in an alphabet with a corresponding symbol from another alphabet.
• Caesar cipherA Caesar cipher is a substitution cipher that shifts each alphabetic letter by a fixed number of positions with wrap-around.
• constructor methodA constructor is a function or language mechanism that creates an instance of a type from supplied component values.
• IOIO is Julia's abstract supertype for values that provide input and output operations.
• data typeA type is a classification of values that determines their representation and the operations applicable to them in a programming language.
• length propertylength is a Julia function that returns the number of elements in a collection or the size of a supported object.
• Project.tomlProject.toml is a Julia project metadata file that defines an environment's package identity, dependencies, and related metadata.
• higher-order functionA higher-order function is a function that takes one or more functions as arguments, returns a function, or both.
• class hierarchyA type hierarchy is an arrangement of types in parent-child relationships that distinguishes abstract types from concrete types.
• number typeA number is a mathematical value representing a quantity or position in a numerical system.
• String functionThe string function converts values, including numbers, into their textual string representation and can combine multiple arguments.
• moduleA module is a Julia namespace that groups related functions, types, constants, and other definitions.
• set operationA set operation is an operation that combines or compares collections according to set-membership rules to produce a result collection.
• mutable objectA mutable type is a Julia type whose instances can have their fields modified after creation.
• UTF-8UTF-8 is a variable-width Unicode encoding that represents code points using one to four bytes and is ASCII-compatible for one-byte characters.
• performancePerformance is the efficiency with which a program executes, commonly evaluated through measures such as runtime or throughput.
• recursionRecursion is a programming technique in which a computation invokes itself on smaller or simpler inputs until a terminating condition is reached.
• closureA closure is a function that captures external state from its enclosing scope rather than receiving that state as an argument.
• NothingThe nothing object is the sole runtime value that is an instance of Julia's Nothing type.
• concrete typeA concrete type is a type that can be directly instantiated or used as the representation of values rather than serving only as an abstract classification.
• subtypingA subtype is a type whose values are also accepted wherever values of a more general supertype are expected.
• just-in-time compilationA just-in-time compiler compiles program code into executable machine code during program execution.
• type safetyType safety is the property that a programming language prevents operations from being applied to values in incompatible ways.
• UnicodeUnicode is a universal character standard that assigns identifiers and encoding rules to characters across writing systems.
• specific impulseSpecific impulse is a measure of rocket-engine propellant efficiency, conventionally expressed as effective exhaust velocity or equivalent thrust per propellant weight flow.
• splitsplit is a Julia function that divides a string into substrings based on a delimiter, character predicate, or whitespace.
• simulationA simulation is a computational representation that models the behavior of a system by advancing its state according to specified rules.
• two-language problemThe two-language problem is the need to combine a productive high-level language with a separate lower-level language to obtain both development convenience and performance.
• parsingParsing is the process of interpreting a textual representation to produce a value of a specified type.
• integerAn integer is a whole number with no fractional component, including positive, negative, and zero values.
• functional, stateless philosophyFunctional programming is a programming paradigm that emphasizes expressions, function composition, and transformations of data with limited mutable state.
• type checkingType checking is the process of verifying that operations are applied to compatible types.
• static typingStatic typing is a language property in which types are associated with expressions and checked before a program runs.
• variableA variable is a named binding that associates an identifier with a value or other computation during program execution.
• type hintsA type annotation is syntax that associates a variable or expression with an explicitly specified type.
• end keywordThe end keyword is a Julia syntax token that can denote the last valid position of an indexed collection as well as terminate compound constructs.
• read-execute-print loopThe Julia REPL is Julia's interactive read-evaluate-print loop for entering expressions and viewing their results.
• floating-point arithmeticA floating-point number is a finite-precision numerical representation that stores a sign, significant digits, and an exponent to approximate real values.
• code pointA code point is a numeric value assigned to an abstract character or other element in a coded character set.
• dev commandThe dev command is a Julia package-manager command that adds a package from a specified local directory for active development.
• interactive programmingInteractive programming is a programming style in which code can be entered, evaluated, and revised incrementally while the program is running.
• ReviseRevise is a Julia package that detects changes to loaded source code and updates the corresponding definitions during development.
• type systemA type system is the set of rules and mechanisms a programming language uses to classify values and constrain or determine valid operations.
• cosine functioncos is a Julia function that computes the cosine of an angle or numeric value.
• promotionA promotion rule specifies how Julia determines a common type when values of different types participate in an operation.
• set intersectionSet intersection is the operation that produces the elements shared by two or more sets.
• iterateiterate is Julia's generic function implementing the iteration protocol by returning the next element and iteration state or indicating that iteration is complete.
• printstyledprintstyled is a Julia function that writes text with terminal styling such as foreground or background colors and text attributes.
• promote_rulepromote_rule is a Julia function whose methods specify the common type to which two types are promoted.
• promotepromote is a Julia function that converts multiple values to an appropriate common type and returns them as a tuple.
• tupleA tuple is a fixed-size ordered collection whose elements may have different types and whose contents cannot be changed.
• multistage rocketA multistage rocket is a launch vehicle composed of separable propulsion stages that are discarded or exposed sequentially during flight.
• vectorVector is Julia's parametric one-dimensional array type for elements of a specified type.
• accelerationAcceleration is the rate at which an object's velocity changes over time.
• package modePackage mode is a Julia package-management REPL mode that accepts commands for creating and managing packages.
• angle typeAn angle type is a numeric type whose values represent angles according to a particular angular unit or representation.
• type objectA type object is a Julia value representing a type and capable of being passed, stored, or operated on like other values.
• readlinereadline is a Julia function that reads one line of text from an input stream.
• element typeAn element type is the type specification governing the values stored as elements of a collection such as an array.
• massMass is a physical quantity measuring an object's inertia and its contribution to gravitational interactions.
• rocket engineA rocket engine is a propulsion device that produces thrust by expelling propellant.
• slicingArray slicing is the selection of one or more elements or subarrays from an array by specifying index ranges or positions.
• @view@view is a Julia macro that transforms an array slice expression into a non-copying view of the selected data.
• accessor methodA setter method is a method that assigns or updates a property of an object or structured value.
• attributeA field is a named component declared within a composite type and stored in each value of that type.
• code unitA code unit is a fixed-size storage unit used by an encoding to represent a Unicode code point in memory.
• filteringArray filtering is an operation that selects or transforms array elements according to a criterion.
• primitive data typeA primitive type is a type represented directly by a language implementation rather than as a collection of user-defined fields.
• characterA character is a single textual symbol represented as a value in a programming language.
• missing valueMissing data is information absent from a collected dataset because it was not recorded, was lost, or is otherwise unavailable.
• setdiffsetdiff is a Julia function that returns the elements present in one collection but absent from one or more other collections.
• regular expressionA regular expression is a pattern language for specifying text sequences to search for or match.
• openopen is a Julia function that establishes access to a file or other stream and returns an associated IO object.
• cipherA cipher is a cryptographic algorithm that transforms plaintext into ciphertext and can provide a corresponding transformation for recovery.
• sine functionsin is Julia's built-in function for computing the sine of an angle or numeric value.
• character encodingCharacter encoding is a scheme for representing textual characters as numeric code units in storage or transmission.
• lastindexlastindex is a Julia function that returns the final valid index of an indexed collection or string.
• nextindnextind is a Julia function that returns the next valid index for an indexed collection or string.
• variable-length encodingVariable-length character encoding represents different characters with different numbers of code units or bytes.
• joinjoin is a Julia function that combines iterable elements with a separator or writes the resulting text to an I/O object.
• partial applicationPartial application is a functional programming technique that fixes some arguments of a function to produce a new function requiring fewer arguments.
• holy traits patternThe holy traits pattern is a Julia design pattern that exposes an object's capabilities through trait types or trait-returning methods.
• IteratorSizeIteratorSize is a Julia iterator trait describing whether and how the number of elements in an iterator is known.
• set unionunion is a Julia function and set operation that returns the distinct elements occurring in any of its input collections.
• Taylor seriesA Taylor series is a power series representing a function as an expansion around a specified point using its derivatives.
• literalA number literal is a source-code notation that directly represents a numeric value with digits rather than a variable name.
• arbitrary-precision integerBigInt is Julia's arbitrary-size integer type, capable of representing integers beyond fixed-width integer ranges.
• @test@test is a Julia macro that evaluates an expression as an individual test assertion.
• zipzip is a Julia function that combines corresponding elements from multiple iterables into tuples.
• add commandThe add command is a Julia package-manager command that adds a package to an environment and records a package version.
• import/export syntaxAn export statement is Julia syntax that makes selected bindings from a module available without requiring the module-name prefix.
• lpadlpad is a Julia function that left-pads a string to a specified length using a chosen character or a space by default.
• rpadrpad is a Julia function that right-pads a string to a specified length using a chosen character or a space by default.
• includeinclude is Julia's include function loads and evaluates the contents of a source code file in the current session.
• unsigned integerAn unsigned integer type represents nonnegative whole numbers within a fixed bit width.
• symbolA symbol is a Julia identifier form that can name a function and, when suitable, enable infix invocation.
• package managerA package manager is software that discovers, installs, updates, and manages reusable software packages and their dependencies.
• exclamation markAn exclamation mark in a Julia function name conventionally indicates that the function may mutate one of its inputs and is part of the function's name.
• mutating functionA mutating function is a function that can modify one or more of its input objects rather than producing all results in new objects.
• binary searchBinary search locates an element in an ordered collection by repeatedly comparing against the middle of a narrowing search range.
• membership testA membership test determines whether a specified element belongs to a collection.
• testSoftware testing is the systematic evaluation of software behavior using prescribed inputs and expected results to detect defects and verify correctness.
• manifest.tomlManifest.toml is a Julia environment file that records the resolved packages and dependency information needed for reproducible package loading.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.