Index

[SYMBOL][A][B][C][D][E][F][G][H][I][J][K][L][M][N][O][P][Q][R][S][T][U][V][W][X][Y]

SYMBOL

_ (underscore character)2nd3rd4th
, (comma) character
; (semicolon) character2nd
: (colon) character
: symbol
!= operator
!$ operator
. (dot) character
.. operator
“ (double-quote) character2nd
( ) (parentheses)
[] (square brackets)2nd
{:} syntax2nd
@ character2nd3rd
* operator2nd3rd
/ operator2nd
(backward-slash) character
(newline escape sequence)2nd
(carriage return)
& (ampersand) character
# (hash) character
% operator
` (backtick) character2nd
^ operator2nd3rd
+ operator2nd3rd
= (equals) character2nd
=~ operator
| operator
~ character
$ operator2nd3rd4th5th6th
$! operator2nd
80 port
404 error2nd
5000 port
7687 port

A

abstract syntax tree.
    See AST.
accept procedure2nd
acceptAddr variant
add procedure2nd3rd
addr keyword
advantages of Nim
  catches errors ahead of time
  efficient
  flexible
  readable
  stands on its own
algorithm module
algorithms
allocShared procedure
ampersands
anonymous procedures

Aporia IDE
  installing
  overview
application-level package managers

architecture
  of chat applications
    client components
    finished product
    network architectures
    network models
    server components
  of web applications
    routing in microframe-works
    Tweeter

archives, for compiler
  downloading
  extracting
  moving to safe location

arguments
  command-line
  in macros
array type
arrays, bounds-checked
AssertionFailed exception
AST (abstract syntax tree)2nd3rd
ast module
async await
async procedure
asyncCheck command2nd3rd
asyncdispatch module2nd3rd
asyncftpclient module
asynchronous data transfer
  adding network functionality to client
  creating new Client instance to hold data about client
  final results of
  processing client messages
  sending messages to other clients
  testing server without client
asynchronous execution, versus synchronous
asynchronous I/O (input/output)
  await keyword
  difference between synchronous and asynchronous execution
  event loops
  example using callbacks
  Future type
asynchronous sockets
AsyncHttpClient type
asynchttpserver module
asyncnet module2nd3rd
AsyncSocket type
auto type
await keyword2nd

B

backend, of JavaScript
  using Canvas API wrapper
  wrapping canvas elements
backticks2nd
backward-slash character
basic types
  Boolean
  characters
  floating-points
  integers
  strings
benchmark tests
bigints package
binary notation
bindAddr procedure
Bitwise operations
block keyword
blocked state
blocking input/output, using spawn to avoid
body parameter
Boehm
Boolean operations
Boolean type2nd
--boundsChecks option
break keyword
buffer overread
buffer string
build scripts
busy waiting
buttons, adding

C

C ++ programming language, features of
c command2nd
C library

C programming language
  building compiler from source code of
    adding Nim programming language to PATH
    compiling
    downloading archives
    extracting archives
    moving archives to safe location
    verifying installation of
  features of
  wrapping external libraries
    creating wrapper for SDL (Simple DirectMedia Layer) library
    downloading SDL (Simple DirectMedia Layer) library
    dynamic linking
    using SDL wrappers
    wrapping SDL procedures
    wrapping SDL types
  wrapping procedures
  wrapping types
c subcommand
c1 sequence
c2nim tool
calculate macro
callback hell
callbacks, example of asynchronous input/output using
camelCase2nd
Canvas API, using wrappers
canvas elements, wrapping
CanvasRenderingContext2D type
carriage return
case keyword
case statements
cd command
cfg parameter
chan variable

channels
  overview
  sending and receiving messages with
channels module2nd
character type2nd3rd
character-escape sequences

chat applications
  architecture of
    client components
    finished product
    network architectures
    network models
    server components
  writing
    first steps
    implementing protocols
    retrieving input in client components
    transferring data using sockets
check command
chunks2nd
Clang
client components, retrieving input in
  reading data from standard input streams
  retrieving command-line parameters supplied by users
  using spawn to avoid blocking input/output
client module
Client type

clients
  adding network functionality to
  creating instance to hold data about
  creating new Client instance to hold data about
  processing messages
  sending messages to
  testing server without
client-server module
close procedure2nd
cmp procedure
code blocks, passing to templates
code statements
collection types
  arrays
  sequences
  sets
colon character
comma character
command not found error
command-line applications
command-line arguments2nd

command-line parameters
  overview
  supplied by users, retrieving
command-line tools, Nimble
comments
community, for Nim programming language2nd
Comparable concept
comparison operators
compatibility, of types
compilation

compiler
  architecture
  building from C sources
    adding Nim programming language to PATH
    compiling
    downloading archives
    extracting archives
    moving archives to safe location
    verifying installation of
  compiling
  installing
  verifying installation of
Compiler User Guide
compile-time error
compile-time function execution.
    See CTFE.
Comprehensive Perl Archive Network.
    See CPAN.
concatenation operator
concept keyword
concurrency, parallelism vs.
config macro
configuration DSLs, creating
  generating constructor procedures
  generating load procedures
  generating object types
  starting configurator project
  testing configurators
connect procedure2nd
connected flag2nd
const char * type
const keyword
constraining generics
constructor procedures, generating
Container variable
contextAttributes argument
continue keyword
control flow mechanisms
controllers, developing
  adding Follow buttons
  extending / routes
  implementing / createMessage routes
  implementing /follow routes
  implementing /login routes
  implementing user routes
could not load error
counter variable2nd
counterLock
CPAN (Comprehensive Perl Archive Network)
cpp command
crash procedure
createDatabase module
createLoadProc procedure
createMessage procedure2nd
/createMessage routes, implementing
createRefType procedure
createThread procedure2nd3rd
createWindowAndRenderer procedure
critbits module
cross-compilation
cstring type
CTFE (compile-time function execution)2nd
curly brackets2nd
currentUser parameter

D

D programming language, features of
-d release flag
daemonize package
daemons

data
  client
  manipulating
  overview
  parsing
    manually using parseutils module
    manually using split procedure
    processing each line of Wikipedia page-counts files
    understanding Wikipedia page-counts format
    using regular expressions
    Wikipedia page-counts format
  reading from standard input streams
  retrieving from databases
  storing in databases
    setting up databases
    setting up types
    testing databases
  transferring asynchronously
    adding network functionality to client
    creating new Client instance to hold data about client
    final results of
    processing client messages
    sending messages to other clients
    testing server without client
  using sockets to transfer
    asynchronous input/output
    asynchronously
data parameter
data parsing
data structures
  modules
  sets module
  tables module
data variable
database module

databases
  retrieving data from
  setting up
  storing data in
  testing
DbConn object2nd
db_mysql module2nd
db_postgres module2nd
db_sqlite module2nd
Debian-based distributions
decimal notation
declarative templates
declareVar template
default parameters
defined procedure
delete procedure
dependencies, specifying in Nimble
deploying web applications
  configuring Jester microframework
  setting up reverse proxy

developing
  controllers
    adding Follow buttons
    extending/routes
    implementing / createMessage routes
    implementing /follow routes
    implementing /login routes
    implementing user routes
  front-page view
  packages in Nimble package manager
    giving meaning to version numbers
    storing different versions of single package
  user view
  web application view
development environments.
    See IDEs.
directory layout, of packages in Nimble
discard keyword2nd
discardable pragma2nd
distributed version control systems.
    See DVCSs.
DLL (dynamic-link library), could not load
do keyword2nd
do notation
doAssert procedure2nd3rd

documentation
  Nimble
  standard library
domain-specific languages.
    See DSLs.
dot character
double-quote character2nd

downloading
  compiler archives
  SDL libraries
drawLines procedure

DSLs (domain-specific languages)
  creating configuration
  overview
dumpTree macro2nd
DVCSs (distributed version control systems)

dynamic linking
  overview
  vs. static linking
dynamic type systems
dynamic-link library.
    See DLL.
dynlib pragma2nd

E

echo procedure2nd3rd
efficiency of Nim
elif keyword
else branch
else keyword
EmbedElement type
empty nodes
end keyword2nd3rd
enum types
environment variables
equals character2nd
errors, catching ahead of time
escape procedure
event loops
except branch
except keyword

exceptions
  handling
  in threads
execCmd procedure
execCmdEx procedure

execution
  difference between synchronous and asynchronous
  external processes
  of compile-time function
  threads

execution time
  of parallel_counts
  of sequential_counts
existsDir procedure
existsFile procedure
expectKind procedure
export marker
exportc procedure
external libraries, C programming language
external package
external processes, executing
extracting, compiler archives

F

F4 shortcut, Aporia
F5 shortcut, Aporia
Facebook Messenger
failed procedure

features
  of C ++ programming language
  of C programming language
  of D programming language
  of Go programming language
  of Java programming language
  of Lua programming language
  of Nim programming language2nd
    compilation
    instability of newer
    memory management
    metaprogramming
    powerful type system
    style insensitivity
  of Python programming language
  of Rust programming language
FFIs (foreign function interfaces)2nd3rd
FIFO (first-in-first-out)

files
  parsing each line in
  using iterators to read fragments of
filesystems
fill procedure
fillString procedure2nd
filter procedure
filters
findMessages procedure2nd
findUser procedure2nd
flags argument
flexibility of Nim
float type2nd3rd
floating-point type
flow, controlling
FlowVar container
FlowVar types, retrieving return values from
fmReadWrite mode
Follow buttons, adding
follow procedure2nd
/follow route, implementing
foo identifier
for loop2nd3rd4th
for statement
foreign function interface
  static vs. dynamic linking
  type compatibility
  wrapping C procedures
foreign-key constraint
format string
forums
forward declaration
FP (functional programming)2nd

fragments
  overview2nd
  using iterators to read
free function
from statement
front-page view, developing
full-stack applications
future module
Future type

G

garbage-collected memory
GC (garbage collector) safety, with threads
GCC compiler
generics
  concepts
  constraining
  in type definitions
  procedures
get procedure
getAppFilename procedure
getCurrentDir procedure
getElementById procedure
getHomeDir procedure
getStr procedure
git tool
Gitter
global variables2nd
Go programming language, features of
group communication
guarded variables
guards, preventing race conditions with
GUIs (graphical user interfaces)
gzipped archives

H

handling exceptions
hash character
hash procedure
hashes module
HashSet[string] variable
Haskell
header pragma

help
  community page
  forums
  real-time communication
--help flag
hexadecimal notation
hg tool
hidden fields
home directory
Homebrew
homogeneous arrays
Host header
HT (Hyper-Threading) Technology
HTML templates
htmlgen module
httpclient module
hygiene, of templates
hyphens

I



I/O (input/output)
  asynchronous
    await keyword
    difference between synchronous and asynchronous execution
    event loops
    example using callbacks
    Future type
  reading data from input streams
  retrieving input in client components
    reading data from standard input streams
    retrieving command-line parameters supplied by users
    using spawn to avoid blocking input/output
  using spawn to avoid blocking
ident argument
Ident node
identifiers, comparing

IDEs (integrated development environments)
  Aporia, installing
  testing new
if statement2nd
immutable variables2nd
import keyword2nd3rd4th
import statement
importc pragma2nd3rd
importcpp pragma2nd
impure modules
in keyword
increment procedure2nd
indentation2nd
IndexError exception
indexing operator
index-out-of-bounds exception
Infix node
init command2nd
init type
initTable procedure
injected variables
input streams
input/output.
    See I/O.
instability, of newer features

install command
  understanding
  using

installing
  Aporia IDE
  compiler
    building from C sources
    getting up-to-date installation info
    verifying installation
  Nim, troubleshooting
  Nimble package manager
  Nimble packages
int type
int64 type
int8 type
integer type
integrated development environments.
    See IDEs.
interfaces.
    See Canvas API; ; foreign function interface.

interfacing with OSs
  executing external processes
  generic operating system services
  with other programming languages
    JavaScript backend
    through foreign function interface
    wrapping external C programming language libraries
  working with filesystems
internet, networking and
interpreter
IntLit node
intsets module
IoT (Internet of Things)
IRC (Internet Relay Chat)2nd
is operator
isMainModule constant
isReady procedure2nd
isRootDir procedure
items iterator2nd
__iter__ method
iterators, reading file fragments with

J

Java programming language, features of
JavaScript, backend
  using Canvas API wrapper
  wrapping canvas elements
Jester2nd3rd
js command

JSON (JavaScript Object Notation)
  generating
  parsing
json module2nd
JsonNode type
JsonNodeKind type

K

KeyError exception
keywords2nd3rd

L

lazy evaluation
len procedure
let keyword
libName

libraries
  external C programming language
  SDL (Simple DirectMedia Layer)
    creating wrappers for
    downloading
libvlc
LIMIT keyword
line feed
lineFlowVar variable
lines iterator
lineTo procedure

linking
  dynamic
  static
list variable
listen procedure2nd
lists module

load procedures
  generating
  overview2nd
localhost
localtime procedure
lock mechanism

locks
  overview
  preventing race conditions with
logging module
/login routes, implementing
loop procedure
Lua programming language, features of

M

macro_rules
macros
  abstract syntax trees
  arguments in
  compile-time function execution
  defining
macros module
main function2nd
main thread
many-to-many communication
map procedure
mapIt procedural
math module2nd
Measure-Command
memory errors
memory management
Message type2nd
messageFlowVar

messages
  client, processing
  sending and receiving between threads
  sending to clients

metaprogramming
  creating configuration DSLs
    generating constructor procedures
    generating load procedures
    generating object types
    starting configurator project
    testing configurators
  generics
    concepts
    constraining
    in type definitions
    procedures
  macros
    abstract syntax trees
    arguments in
    compile-time function execution
    defining
  templates
    hygiene
    parameter substitution in
    passing code blocks to

microframeworks
  Jester, configuring
  routing in
MinGW package

modules
  core
  for threads2nd
  impure
  namespacing
  pure
  sets
  tables
  threadpool
    defined
    executing
    retrieving return values from FlowVar types
    using spawn with
moduleVersion variable2nd
MongoDB
mostPopular variable
moveTo procedure
mult procedure
multiline comment, creating
multiLine variable
multitasking
mutable variables
MyAppConfig object
myMax procedure2nd
MyPkg.nimble file
myProc procedure
myUndeclaredVar

N

name variable
namespacing
net module2nd
netAddr field
network architectures
network functionality, adding to clients
networking, internet and
New Repository button, GitHub
newException procedure
newIdentNode procedure
newline escape sequence2nd
newSeq procedure
newServer procedure
newSocket constructor

Nim programming language
  adding to PATH
  advantages of
    catches errors ahead of time
    efficient
    flexible
    readable
    stands on its own
  command not found
  compiler
    C compiler disagrees on target architecture
    compiling
    downloading archives
    extracting archives
    installing
    moving archive to safe location
  defined
  features of2nd
    compilation
    memory management
    metaprogramming
    powerful type system
    style insensitivity
  implementation of
  installing
    Aporia IDE
    testing new IDE
    troubleshooting
  shortcomings of
  use cases
.nimble files, writing
nimble init command2nd
nimble install command

Nimble package manager
  command-line tool
  creating packages in
    choosing names
    Nimble package directory layout
    specifying dependencies
    writing .nimble files
  developing packages in
    giving meaning to version numbers
    storing different versions of single package
  installing
  installing packages
    understanding install command
    using install command
  package directory layout
  packages, defined
  publishing packages
nimble publish command
NimKernel
NimNode
nnk prefix
nnkEmpty node
nnkIdent node
nominative typing
nonblocking behavior
non-ref types
NoSQL database
NOT NULL key constraint
notInjected variable
number variable
numbers sequence
numbers variable

O

-o flag
object keyword

object types
  generating
  overview
OCaml
octal notation
of branch
oldBufferLen
one-to-one communication
online documentation
OOP (object-oriented pro-gramming)2nd
open procedure2nd
openAsync procedure
OpenSSL library
operator2nd3rd
ORDER BY keyword
os module2nd3rd
osinfo package
osproc module
OSs (operating systems), interfacing with
  executing external processes
  generic operating system services
  working with filesystems
overloading procedures

P



packages
  creating in Nimble package manager
    choosing names
    Nimble package directory layout
    specifying dependencies
    writing .nimble files
  defined
  developing in Nimble package manager
    giving meaning to version numbers
    storing different versions of single package
  directory layout of
  installing in Nimble package manager
  publishing with Nimble package manager
  storing different versions of
Pageview API, Wikipedia
pairs iterator
Par node
parallel_counts, execution time of

parallelism
  concurrency vs.
  dealing with race conditions
    preventing with guards
    preventing with locks
    sending and receiving messages between threads using channels
  parsers
    execution time of parallel_counts
    measuring execution time of sequential_counts
    parallel readPageCounts procedure
    parallelizing sequential_counts
    parse procedure
    parseChunk procedure
    type definitions
  parsing data
    parsing Wikipedia page-counts format
    processing each line of Wikipedia page-counts files
    understanding Wikipedia page-counts format
  sequential_counts
  using threads in Nim
    exceptions in threads
    GC (garbage collector) safety
    thread pools
    threads modules
param1 variable
paramCount procedure2nd

parameters
  command-line
  of procedures
  substitution of, in templates
paramStr() procedure2nd3rd
parentDir procedure
parentheses
parse procedure2nd
parseChunk procedure
parseJson procedure
parseMessage procedure2nd
parseopt module2nd
parsers, parallelizing
  execution time of parallel_counts
  measuring execution time of sequential_counts
  parallel readPageCounts procedure
  parallelizing sequential_counts
  parse procedure
  parseChunk procedure
  type definitions

parseutils module
  manually parsing data with
  overview

parsing
  command-line arguments
  data
    in Wikipedia page-counts format
    manually using parseutils module
    manually using split procedure
    processing each line of Wikipedia page-counts files
    understanding Wikipedia page-counts format
    using regular expressions
  each line in files
  JSON
parsingex application
PascalCase

PATH variable
  adding Nim programming language to
  overview
path-manipulation procedures
PCRE library
peer-to-peer networking
ping messages
PNG library, Python
pointer arithmetic
points array
points parameter
poll procedure2nd3rd4th
pollEvent procedure
pop pragma
printf prototype
private keyword
proc keyword2nd3rd
procedural macros
procedural programming

procedures
  anonymous
  constructor, generating
  generic
  load, generating
  overloading
  parameters of
  returning values from
  wrapping
    in C programming language
    in SDL (Simple Direct-Media Layer)
processMessages procedure
programming languages, differentiating
protocol module2nd3rd4th
protocols, implementing
  generating JSON
  modules
  parsing JSON
ptr type
public keyword
publishing packages, with Nimble package manager
pull request
pure modules
pure pragma
push pragma
Python programming language, features of

Q

queues module
quit procedure2nd
quote procedure

R

-r option
race conditions
  sending and receiving messages between threads
  using guards to prevent
  using locks to prevent
raise keyword
raise statement
randomNumber variable
re module2nd
readability, of Nim programming language
readAll procedure
readChars procedure
readFile function
reading data, from standard input streams
readLine procedure2nd

readPageCounts procedure
  overview
  parallel version of
real-time communication, to get help
receiving messages, between threads using channels
recv procedure2nd
recvLine procedure
redirect procedure
Redis
ref keyword
ref object
ref types
regular expressions, parsing data with
renderer.clear statement
renderLogin procedure
renderMain procedure2nd
renderMessages procedure
renderTimeline procedure2nd
renderUser procedure2nd3rd
repeat template
repository
repr procedure
result variable2nd3rd4th
resultChan channel
resultVar procedure
resultVar2 procedure
resultVar3 procedure

retrieving
  command-line parameters supplied by users
  data from databases
  input in client components
    reading data from standard input streams
    using spawn to avoid blocking input/output
  return values from FlowVar types
return keyword
returning values, from procedures
reverse procedure
reverse proxy, setting up
root node
root variable

route
  extending
  overview2nd
routes block
Rumpf, Andreas2nd
Rune type
runForever procedure2nd
runtime errors
Rust programming language, features of

S

sayHello procedure
SDL (Simple DirectMedia Layer)
  libraries
    creating wrappers for
    downloading
  using wrappers
  wrapping procedures
  wrapping types
sdl module
SdlEvent type
SDL_INIT_VIDEO flag
SdlRenderer
SdlRendererPtr
SdlWindow
SdlWindowPtr
search command
seconds variable
semicolon2nd
send procedure2nd

sending messages
  between threads using channels
  to clients
seq type
sequence type

sequential_counts
  measuring execution time of
  parallelizing
sequtils module
server component
server module
Server type
serverAddr variable

servers
  components of
  testing without clients
set type
Set-Cookie header
setLen
sets module2nd
setup procedure
shared library files
sharing memory
shortcomings of Nim
showData thread
showNumber procedure
Simple DirectMedia Layer.
    See SDL.
Sinatra
Slack
Slice object
SMT (simultaneous multithreading) technology
smtp module
snake_case
socket variable

sockets
  defined
  transferring data with
    asynchronous I/O
    asynchronously
sort procedure
sorted procedure

spawn
  using to avoid blocking input/output
  using with threadpool modules

split procedure
  manually parsing data with
  overview
splitFile procedure
splitLines iterator
splitPath procedure
sql procedure
SQLite library
square brackets2nd
src directory

standard library
  algorithms
  core modules
  data structures
    modules
    sets module
    tables module
  for networking
  interfacing with OSs
    executing external processes
    generic operating system services
    working with filesystems
  manipulating data
  modules
  overview
    impure modules
    online documentation
    pure modules
    wrappers
  understanding data
startsWith integer
statements identifier
statements, splitting
static keyword
static linking, vs. dynamic linking
static type systems
staticExec procedure
staticRead procedure
Stats type
stdin variable
StmtList node2nd
storage duration

storing
  data in databases
    setting up databases
    setting up types
    testing databases
  defining storage
  different versions of single package
streams, reading data from
string formatting operator
string type2nd
stropping
struct tm type
structural typing
structures of data
  modules
  sets module
  tables module
strutils module2nd3rd
style insensitive2nd3rd
subroutines2nd
subscribing, Twitter
substitution, of parameters in templates
substr procedure
surname argument
switch statements
synchronous execution

syntax
  abstract syntax trees
  comments
  indentation
  keywords
system module2nd3rd4th
system.cmp procedure
system-level package managers

T

tables module2nd
tags
tailDir procedure
target architecture, Nim and C compiler disagree on
task
TCP sockets
telnet application
templates
  hygiene
  parameter substitution in
  passing code blocks to

testing
  configurators
  new IDEs
  server without clients
thread module
threadpool modules
  defined
  executing
  retrieving return values from FlowVar types
  using spawn with
threads
  exceptions in
  GC (garbage collector) safety
  modules
  sending and receiving messages between, using channels
  using pools
    defined
    retrieving return values from FlowVar types
    using spawn with
time command
time procedure
TimeInfo object2nd
TimeInterval object
time_t type
tokens
toLowerAscii
top-level statements
toString parameter2nd
toUpper procedure
toUpperAscii

transferring data
  asynchronously
    adding network functionality to client
    creating new Client instance to hold data about client
    final results of
    processing client messages
    sending messages to other clients
    testing server without client
  using sockets
    asynchronous I/O (input/output)
    asynchronously
transport protocol
triple-quoted string literals
troubleshooting
  could not load DLL
  Nim and C compiler disagree on target architecture
  Nim command not found
try keyword
try statement
tryRecv procedure
tuple types
tuple unpacking2nd
Tweeter, architecture of

Twitter clones, building
  architecture of web applications
  deploying web applications
  developing controllers
  developing web application view
  getting started
  storing data in databases
type classes
type definitions2nd
type keyword
type mismatch error
type section2nd
type systems
typed arguments
typedesc parameter

types
  compatibility of
  wrapping
    in C programming language
    in SDL (Simple Direct-Media Layer).
    See basic types; ; collection types; ; object types; ; user-defined types.

U

UDP sockets
UFCS (Uniform Function Call Syntax)2nd
Uint32 type
underscore character2nd3rd4th
Unicode characters
unicode module2nd
unindent procedure
UNIX time
unsigned integer
untyped arguments
user routes, implementing
User type
user view, developing
user-defined types
  enums
  objects
  tuples
userLogin procedure
users, retrieving command-line parameters supplied by
utils module

V

values, returning from procedures
var keyword2nd

variables
  defining
  overview
varName variable
--ver flag2nd
ver variable
verifying installation of compiler
version field
version key

versions
  numbers for, giving meaning to
  storing different versions of single package

view
  of front page
  of user
  of web applications
VM (virtual machine)
void procedure

W

waitFor procedure
walkDir iterator
walkFiles iterator

web applications
  architecture of
    architecture of Tweeter
    routing in microframe-works
  deploying
    configuring Jester micro-framework
    setting up reverse proxy
web pages, retrieving
WhatsApp
when statement
WHERE clause
while loop2nd3rd
while statement
whitespace character

Wikipedia page-counts
  files, processing each line
  finding most popular article
  format
    parsing
    understanding
windows symbol

wrappers
  Canvas API
  SDL (Simple DirectMedia Layer)
    creating for libraries
    using

wrapping
  C programming language procedures
  C programming language types
  canvas elements
  external C libraries
    creating wrappers for SDL library
    downloading SDL library
    dynamic linking
    using SDL wrappers
    wrapping SDL procedures
    wrapping SDL types
writeFile procedure

writing
  .nimble files
  chat applications
    first steps
    implementing protocols
    retrieving input in client components
    transferring data using sockets

X

XML parsers
xmldom module
xmltree module2nd

Y

Yum-based distributions

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.118.2.240