Library in a week 2014 will attempt to build a C++ template engine library. Templating engines are very popular libraries that provide a way to separate an application from ouput. Often the output is a html or text that may be developed by an non-programmer or other development team.
Consider the following program which uses the ctemplate library:
//user.tpl
Hello {{NAME}}!
//user.cpp
#include <cstdlib>
#include <iostream>
#include <string>
#include <ctemplate/template.h>
int main() {
std::string user = getenv("USER");
ctemplate::TemplateDictionary dict("example");
dict["NAME"] = user;
std::string output;
ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);
std::cout << output;
return 0;
}
In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.
A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed. In our case the library language will be C++11.
The workshop will work like this. On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design. Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.
Collaboration Tools:
Library in a week 2014 will use a git repository for collaboration and sharing of information.
git clone https://github.com/JeffGarland/liaw2014.git
Also the group will use an email list for discussions beyond face to face meetings.
Level: Beginner to Expert
Attendees should have a basic background in C++.
Axiomatic Programming is commonly defined as structured generic programming. Not unlike Euclidean Geometry, it relies on a simple, constructive, logical system. It lies at the foundation of the STL and many successful generic libraries. This talk focuses on tools support and illustrates how ideas and methods from automated deduction and proof theory influence current and future possible developments of C++ templates.
Library in a week 2014 will attempt to build a C++ template engine library. Templating engines are very popular libraries that provide a way to separate an application from ouput. Often the output is a html or text that may be developed by an non-programmer or other development team.
Consider the following program which uses the ctemplate library:
//user.tpl
Hello {{NAME}}!
//user.cpp
#include <cstdlib>
#include <iostream>
#include <string>
#include <ctemplate/template.h>
int main() {
std::string user = getenv("USER");
ctemplate::TemplateDictionary dict("example");
dict["NAME"] = user;
std::string output;
ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);
std::cout << output;
return 0;
}
In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.
A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed. In our case the library language will be C++11.
The workshop will work like this. On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design. Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.
Collaboration Tools:
Library in a week 2014 will use a git repository for collaboration and sharing of information.
git clone https://github.com/JeffGarland/liaw2014.git
Also the group will use an email list for discussions beyond face to face meetings.
Level: Beginner to Expert
Attendees should have a basic background in C++.
Library in a week 2014 will attempt to build a C++ template engine library. Templating engines are very popular libraries that provide a way to separate an application from ouput. Often the output is a html or text that may be developed by an non-programmer or other development team.
Consider the following program which uses the ctemplate library:
//user.tpl
Hello {{NAME}}!
//user.cpp
#include <cstdlib>
#include <iostream>
#include <string>
#include <ctemplate/template.h>
int main() {
std::string user = getenv("USER");
ctemplate::TemplateDictionary dict("example");
dict["NAME"] = user;
std::string output;
ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);
std::cout << output;
return 0;
}
In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.
A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed. In our case the library language will be C++11.
The workshop will work like this. On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design. Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.
Collaboration Tools:
Library in a week 2014 will use a git repository for collaboration and sharing of information.
git clone https://github.com/JeffGarland/liaw2014.git
Also the group will use an email list for discussions beyond face to face meetings.
Level: Beginner to Expert
Attendees should have a basic background in C++.
Library in a week 2014 will attempt to build a C++ template engine library. Templating engines are very popular libraries that provide a way to separate an application from ouput. Often the output is a html or text that may be developed by an non-programmer or other development team.
Consider the following program which uses the ctemplate library:
//user.tpl
Hello {{NAME}}!
//user.cpp
#include <cstdlib>
#include <iostream>
#include <string>
#include <ctemplate/template.h>
int main() {
std::string user = getenv("USER");
ctemplate::TemplateDictionary dict("example");
dict["NAME"] = user;
std::string output;
ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);
std::cout << output;
return 0;
}
In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.
A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed. In our case the library language will be C++11.
The workshop will work like this. On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design. Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.
Collaboration Tools:
Library in a week 2014 will use a git repository for collaboration and sharing of information.
git clone https://github.com/JeffGarland/liaw2014.git
Also the group will use an email list for discussions beyond face to face meetings.
Level: Beginner to Expert
Attendees should have a basic background in C++.
Library in a week 2014 will attempt to build a C++ template engine library. Templating engines are very popular libraries that provide a way to separate an application from ouput. Often the output is a html or text that may be developed by an non-programmer or other development team.
Consider the following program which uses the ctemplate library:
//user.tpl
Hello {{NAME}}!
//user.cpp
#include <cstdlib>
#include <iostream>
#include <string>
#include <ctemplate/template.h>
int main() {
std::string user = getenv("USER");
ctemplate::TemplateDictionary dict("example");
dict["NAME"] = user;
std::string output;
ctemplate::ExpandTemplate("example.tpl", ctemplate::DO_NOT_STRIP, &dict, &output);
std::cout << output;
return 0;
}
In this example the output is simple text, but the template file could be replaced with html or json and the application would not need to be changed.
A templating engine has two languages - the markup langauge the allows a text template to be filled in by an application and the library langauge for the application to be developed. In our case the library language will be C++11.
The workshop will work like this. On day 1 I will provide motiviation and an overview of the library development. We will split into individuals and groups to attack various aspects of the library and markup languge design. Some groups may look at existing libraries for inspiration providing presentations on the best aspects of the other libraries. From that point forward it will be up to the group to direct the remainder of the workshop.
Collaboration Tools:
Library in a week 2014 will use a git repository for collaboration and sharing of information.
git clone https://github.com/JeffGarland/liaw2014.git
Also the group will use an email list for discussions beyond face to face meetings.
Level: Beginner to Expert
Attendees should have a basic background in C++.
C++ 98/03 already has a reputation for overwhelming complexity compared to other programming languages. The raft of new features in C++ 11/14 suggests that the complexity in the next generation of C++ code bases will overwhelm still further. The planned C++ 17 will probably worsen matters in ways difficult to imagine presently.
Countervailing against this rise in software complexity is the hard de-exponentialisation of computer hardware capacity growth expected no later than 2020, and which will have even harder to imagine consequences on all computer software. WG21 C++ 17 study groups SG2 (Modules), SG7 (Reflection), SG8 (Concepts), and to a lesser extent SG10 (Feature Test) and SG12 (Undefined Behaviour), are all fundamentally about significantly improving complexity management in C++ 17, yet WG21's significant work on improving C++ complexity management is rarely mentioned explicitly.
This presentation pitches a novel implementation solution for some of these complexity scaling problems, tying together SG2 and SG7 with parts of SG3 (Filesystem): a standardised, but very lightweight, transactional graph database based on Boost.ASIO, Boost.AFIO and Boost.Graph at the very core of the C++ runtime, making future C++ codebases considerably more tractable and affordable to all users of C++.
Position Paper (Right click and save as.)
