.. title: PAR Class 25, Mon 2019-04-15
.. slug: class25
.. date: 2019-04-15
.. tags: class
.. category: 
.. link: 
.. description: 
.. type: text

.. raw:: html

   <style> .red {color:red} </style>
   <style> .blue {color:blue} </style>

.. role:: red
.. role:: blue

.. sectnum::
.. contents:: Table of contents::
..



Sign up for final presentations
-------------------------------

Next week, Mon or Thurs.

https://doodle.com/poll/kcsek2wi39s97uzm







Software tips
--------------------------------------

Git
===

Git is good to simultaneously keep various versions.  A git
intro:

Create a dir for the project::

  mkdir PROJECT; cd PROJECT

Initialize::

  git init

Create a branch (you can do this several times)::

  git branch MYBRANCHNAME

Go to a branch::

  git checkout MYBRANCHNAME

Do things::

  vi, make, ....

Save it::

  git add .; git commit -mCOMMENT

Repeat

I might use this to modify a program for class.


Freeze decisions early: SW design paradigm
===========================================

One of my rules is to push design decisions to take effect as
early in the process execution as possible.  Constructing
variables at compile time is best, at function call time is
2nd, and on the heap is worst.

a. If I have to construct variables on the heap, I construct few and large
   variables, never many small ones.

#. Often I compile the max dataset size into the program, which permits
   constructing the arrays at compile time.  Recompiling for a larger
   dataset is quick (unless you're using CUDA).

   Accessing this type of variable uses one less level of pointer than
   accessing a variable on the heap.  I don't know whether this is faster
   with a good optimizing compiler, but it's probably not slower.

#. If the data will require a dataset with unpredictably sized components, such as a ragged array, then I may do the following.

   i. Read the data once to accumulate the necessary statistics.

   #. Construct the required ragged array.

   #. Reread the data and populate the array.



CPPCON
-----------

CppCon is the annual, week-long face-to-face gathering for the entire C++ community.
https://cppcon.org/

https://cppcon2018.sched.com/

CppCon 2014: Herb Sutter "Paying for Lunch: C++ in the ManyCore Age"
https://www.youtube.com/watch?v=AfI_0GzLWQ8

CppCon 2016:  Combine Lambdas and weak_ptrs to make concurrency easy (4min)
https://www.youtube.com/watch?v=fEnnmpdZllQ

A Pragmatic Introduction to Multicore Synchronization
by Samy Al Bahra.
https://www.youtube.com/watch?v=LX4ugnzwggg


CppCon 2018: Tsung-Wei Huang “Fast Parallel Programming using Modern C++”
https://www.youtube.com/watch?v=ho9bqIJkvkc&list=PLHTh1InhhwT7GoW7bjOEe2EjyOTkm6Mgd&index=13

CppCon 2018: Anny Gakhokidze “Workflow hacks for developers”
https://www.youtube.com/watch?v=K4XxeB1Duyo&list=PLHTh1InhhwT7GoW7bjOEe2EjyOTkm6Mgd&index=33

CppCon 2018: Bjarne Stroustrup “Concepts: The Future of Generic Programming (the future is here)”
https://www.youtube.com/watch?v=HddFGPTAmtU

CppCon 2018: Herb Sutter “Thoughts on a more powerful and simpler C++ (5 of N)”
https://www.youtube.com/watch?v=80BZxujhY38

CppCon 2018: Jefferson Amstutz “Compute More in Less Time Using C++ Simd Wrapper Libraries”
https://www.youtube.com/watch?v=80BZxujhY38

CppCon 2018: Geoffrey Romer “What do you mean "thread-safe"?”
https://www.youtube.com/watch?v=s5PCh_FaMfM