Architecture
Background
The kpt’s design mirrors the Kubernetes control-plane architecture – with multiple programs (e.g. controllers) reading and writing shared configuration data (i.e. resources).
Influences
kpt vs kubernetes:
- While the Kubernetes control-plane reads / writes configuration data stored by the apiserver (e.g. in etcd or some other database), kpt reads / writes configuration data stored as local files (as well as supporting other sources / destinations – http, git, etc).
- While in the Kubernetes control-plane controllers are implicitly triggered through watches, in kpt programs are explicitly triggered through invoking kpt (although this can be done by automation).
Kpt provides a hybrid GitOps + resource-controller model. It’s architecture is designed to enable composing loosely coupled solutions through reading and writing to a shared data model (e.g. resources, controllers, OpenAPI).
Design Principles
Configuration-as-Data vs Configuration-as-Code
kpt packages configuration as data (APIs) rather than as code (templates / DSLs). In this model, the configuration is static data, which many tools may read & write.
This model has its roots in the Unix Philosophy:
Expect the output of every program to become the input to another, as yet unknown, program
As well as in the Kubernetes control-plane where resources are read and written by loosely coupled controllers.
Shift-Left & GitOps
By enabling resource-controller style systems to be built on configuration files before applying them to the cluster, kpt shifts the control-plane left – enabling more issues to be caught before they are pushed into a cluster.
- Cluster changes may be reviewed, approved, validated, audited and rolled back using git
- Git automation may be applied to changes to cluster state
Shift-Right vs Shift-Left
- Read resources from apiserver => Read resources from files
- Write resources to apiserver => Write resources to files
- Triggered by watch => triggered by
sh
Composability
Design solutions to work together, expecting the output of each command to be read as input by another.
- Commands read configuration and write configuration.
- The inputs and outputs should be symmetric.
- It should be possible to pipe kpt commands together, and it should be possible to write the output of a kpt command back to its source (updating it in-place).
Tools which read / write data may be developed in different languages and composed together. Tools which write configuration back to the same source it was read from should retain comments set on the input, as the comments may be used by kpt and other tools as metadata.
Programs may be developed independently of one another, with commands built directly into
the CLI – e.g. kpt cfg set
.
Additionally, kpt offers functions as an extension mechanism to simplify publishing logic, and to provide deeper integration with kpt – e.g. invoking functions automatically after kpt commands.
kpt vs kubernetes:
- kpt: resource configuration is read, modified and written back to its source (or another destination)
- resources may be updated using 3-way merge (kpt pkg update)
- kubernetes: resources are read, modified, and written back to the apiserver
- resources may be updated using 3-way merge (kubectl apply)
Resource oriented
Desired system state is expressed using Kubernetes resources – declarative, static data structures. The desired state is changed through modification of resources – these may be done:
- programmatically by manually invoked tools – e.g.
kpt cfg set
- through direct text edits – e.g.
vi
- through forms of automation – e.g. GitHub actions
High-level logic should be built into programs which understand configuration and are capable of generating and transforming it given some context.
Since all tools read and write configuration data, multiple tools may be composed by invoking them against the same configuration data and pipelining their commands.
kpt vs kubernetes:
- kpt:
- read / write files, http, …
- triggered explicitly (kpt invocations)
- kubernetes:
- read / write http
- triggered implicitly (watches)
Schema driven
Type or object specific logic should NOT be built into the tool. Static resource modifications (e.g. set) should be configured using type or object metadata (e.g. schema).
OpenAPI is used for resource schema. Tools may support their own OpenAPI extensions which should co-exist with extensions owned by other tools.
Support for new types should be introduced through new OpenAPI definitions rather than changes to the tool itself.
-
Static per-type and per-object resource transformations should use OpenAPI to tell the tool how to modify a given object
- e.g. where to set
image
forset image
is defined in OpenAPI rather than hard-coded
- e.g. where to set
-
Configuration for individual objects / resources may define custom OpenAPI definitions for that specific instance
- e.g. an nginx Deployment’s
image
may be restricted to the regular expression^nginx:.*$
- e.g. an nginx Deployment’s
kpt vs kubernetes:
- kpt: OpenAPI read from multiple sources – can also be inlined into individual configuration objects as comments
- kubernetes: OpenAPI read from apiserver
Layering
High-level layers should exist to reduce inherent complexity and simplify simple cases. Lower-level layers should remain accessible, but in the background.
Example: When high-level solutions generate lower-level resources, those resources should be accessible to other tools to read and modify them. If an nginx abstraction generates a Deployment and Service, it should be possible for other tools to observe and modify both.
IO
Both kpt inputs and outputs should be recognized by Kubernetes project tools, published as Kubernetes examples or published by the Kubernetes apiserver.
Examples:
kubectl get -o yaml
kubectl apply -f -
github.com/kubernetes/examples
Much like Kubernetes controllers, kpt should be able to read its previous outputs and modify them, rather than generating them from scratch – e.g. read a directory of configuration and write it back to the same directory.
Note: This principle requires symmetric inputs and outputs.
Dynamic logic may be written using templates or DSLs – which would not support the read-write workflow – by merging the newly generated template / DSL output resources with the input resources.
Targets
Unlike the Kubernetes control-plane, which reads and writes from the apiserver, kpt reads and writes from arbitrary sources, so long as they provide resource configuration.
- Local files
- Files stored in git
- Command stdin & stdout
- Apiserver endpoints


| Up | TOC | Index | |||||
| << 6 Mini-Guides | < 7.1 eutest Unit Testing | Up: 7 Included Tools | 7.3 Edx Demonstration Code Editor > | 8 API Reference >> |
7.2 EuDOC Source Documentation Tool
Writing and managing documentation for your programs is made easier with the eudoc tool. eudoc, written entirely in Euphoria, converts text comments embedded in your program, as well as information about routines and identifiers, into documentation that can be saved in a variety of formats, including plain text and HTML.
Since Euphoria comments do not slow down the execution of programs, documentation written inside source-code introduces no speed penalty but is very convenient.
eudoc can also incorporate documentation written externally from your source-code.
You write your material using Creole style markup to format documention. This gives you creative control using elements like headers, fonts, cross-references, tables, etc. The creole program takes the output of eudoc and produces HTML-formatted documentation.
A third party program like htmldoc or wkhtmltopdf may then be used to convert HTML to PDF. creole will also output LaTeX files directly that can be used to create professional PDF files for online viewing or publishing.
7.2.1 Documentation Tags
Documentation is embedded in source-code using the Euphoria line ( -- ) comments. Two special tags, --**** and --** distinguish documentation from comments that will not be extracted.
7.2.2 Generic Documentation
"Generic" documentation starts with the ( --**** ) tag, continues with lines starting with -- in the first column, and ends with the next blank line. The tags and -- will not appear in the documentation.
--**** -- generic text, thus tagged, will be extracted by eudoc -- write your documentation here... -- -- blank line is a terminator, this line is not included
Produces...
generic text, thus tagged, will be extracted by eudoc write your documentation here...
7.2.3 Source Documentation
"Source" documentation starts with the ( --** ) tag. Locate them before a routine or identifier that you wish to be described in your documentation. The eudoc program will extract the "signature" of a routine and combines it with the comments that you write after this tag.
Starting with the source-code file favorite.ex:
--** -- this is my favorite routine public procedure hello( sequence name ) printf(1, "Hello %s!", {name} ) end procedure
Executing eui eudoc -o foo.txt favorite.ex produces:
%%disallow={camelcase} !!CONTEXT:favorite.ex @[hello|] ==== hello <eucode> include favorite.ex public procedure hello(sequence name) </eucode> This is my favorite routine.
Process with eui creole foo.txt:
include favorite.ex public procedure hello(sequence name)
This is my favorite routine.
If you examine the source-code included with Euphoria you will realize how these steps were used to create the documentation you are reading now.
7.2.4 Assembly File
Large projects are managed using an assembly file, which is a list of files (source-code, and external) that will be incorporated into one output file. Look at euphoria/docs/manual.af for the file used to produce this documentation.
7.2.5 Creole Markup
Creole is a text markup language used in wikis, such as the Euphoria Wiki, and for documenting source-code.
- Common Creole tags are:
= Title == Section //italic// **bold** ##fixed## * bullet * lists are * easy to produce || tables || are | | easy to produce | //with bold headers// | <eucode> -- euphoria code is colorized for i=1 to 5 do ? i end for </eucode>
- The previous tags will produce html that looks like...
- Title **
- Section **
- Title **
italic bold fixed
- bullet
- lists are
- easy to produce
| tables | are |
|---|---|
| easy to produce | with bold headers |
-- euphoria code is colorized for i=1 to 5 do ? i end for
- More details can be found at the Euphoria Wiki under CreoleHelp.
7.2.6 Documentation Software
The programs required for creating documentation are hosted on our Mercurial SCM server at http://scm.openeuphoria.org.
eudoc: http://scm.openeuphoria.org/hg/eudoc
creole: http://scm.openeuphoria.org/hg/creole
The program htmldoc is found at... http://www.htmldoc.org/ and http://htmldoc-binaries.org/.
For LaTeX on Windows, we suggest MiKTeX found at... http://miktex.org/ For those on Linux, you should be able to install via your package manager.


--- layout: default title: About permalink: about/ ---
This site was created at April 2017, mainly to record some interesting things I found or problems I solved which may help others.
It is currently hosted by GitHub Pages and all pages are generated by Jekyll and the theme is inspired by MOR10. There are {{ site.posts | size }} posts in {{ site.categories | size }} different categories now.
You can contact me at<EMAIL_ADDRESS>And you can also find me at


You can group elements together using a div as a container.
Styles that you apply to the div apply to all its child elements.
You can investigate the layout of a page using Chrome Developer Tools.
Apply styles to your page. Focus on border, margin, padding. Notice if your elements are display: block or display: inline. Experiment to see what happens when you set or change style properties.
Reference: CSS-Tricks properties list
The
float
CSS property lets us position an element to the left or right of its parent element. When we float an element, it
shifts to the left or right until it touches the edge of its parent, or another floated element.
See the Pen Playable code by Amy Gori ( @amygori) on CodePen.
The
clear
CSS property lets us determine if an element can be next to floating elements that come before it, or if it must be
moved below them.
See the Pen CSS Floats 101 by Amy Gori ( @amygori) on CodePen.
See the Pen 2-column layout with floats by Amy Gori ( @amygori) on CodePen.
To center an element on a page, or inside its containing element, you can set its left-margin and right-margin to auto.
.centered {
margin: 0 auto;
}
Arrange your HTML page's layout using height, width, margins, and floats.
You can move the sidebar to the left if you like. Try editing your personal page to have your name in the top box, links to your social media accounts in the sidebar, content in the main area, and a copyright notice in the footer. Of course, you can put whatever you like on your page!


Dialog Tutorial
View the source of this page to see how a visually appealing, yet fully accessible dialog can be created. The rules for accessible dialogs are laid out in WAI-ARIA 1.0 Authoring Practices
There are two input fields surrounding the "open dialog" button to mimic interactive content outside of the dialog. They have no other purpose than serve as proof of focus being trapped within the dialog once it's shown.


NOTE: All videos of runs are in realtime. Videos have not been altered in anyway.
Optimal Cost: 6532.280
N-Body Cost: 8635.197
Percent Diff.: 32.19%
Optimal Cost: 6532.280
N-Body Cost: 8123.636
Percent Diff.: 24.36%
Optimal Cost: 6532.280
N-Body Cost: 8434.381
Percent Diff.: 29.11%


Number theory
Number theory is the branch of mathematics that is devoted to the study of integers. It plays a significant role in cryptology, because the security of many encryption methods depends on as yet unsolved number theoretical problems, for example the efficient factorization of big integers.
The following four sections allow you to experiment with some number theoretic aspects:


Locations in TREC Dataset
Measurements in TREC Dataset
Sweet Ontology Mappings in TREC
Metadata Quality Score in TREC
Solr Schema
FFMPEG Extractions
Sub concepts of
Human Activity
found in TREC
Analysis
Concept - Human
Concept - Phenomena
Concept - Realm
Concept - Representation
Concept - Matter
Concept - Process
Concept - States
Concept - Property
Main Concept Mapping


Davilee "Davi" C. Marble
Davilee "Davi" C. Marble / May 21, 1945 - October 30, 2019
Services are currently pending.
Cress Funeral Service
1310 Emerald Terrace
Sun Prairie, WI 53590
608-837-9054
Davilee "Davi" C. Marble / May 21, 1945 - October 30, 2019
Services are currently pending.
Cress Funeral Service
1310 Emerald Terrace
Sun Prairie, WI 53590
608-837-9054


Examples: {{ example1 }} or {{ example2 }}
Please note that position is 1-based and only SNP variants are supported


Hello! You just executed the "touch /tmp/hello" command as www-data on your SEANux 1.0 installation.
Details Here


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| actions.js | 69.23% | 18/26 | 100% | 0/0 | 0% | 0/8 | 52.94% | 9/17 | |
| constants.js | 100% | 9/9 | 100% | 0/0 | 100% | 0/0 | 100% | 9/9 | |
| index.js | 76.74% | 66/86 | 80.39% | 41/51 | 88.24% | 15/17 | 37.04% | 10/27 | |
| reducer.js | 34.48% | 10/29 | 19.05% | 4/21 | 16.67% | 1/6 | 27.27% | 6/22 | |
| selectors.js | 78.57% | 11/14 | 100% | 0/0 | 50% | 3/6 | 83.33% | 5/6 |


Let there be food.
This is a sentence about nothing.
A new sentence.
The last sentence didn't end in a period.


Express server with type-graphql.
npx install-peerdeps @boilerz/super-server
import * as superServer from '@boilerz/super-server';
import { Arg, Query, Resolver } from 'type-graphql';
@Resolver()
class GreetingResolver {
@Query(() => String)
public hello(@Arg('name') name: string): string {
return `Hello ${name}`;
}
}
// Start the server with your resolvers
superServer.start({ resolvers: [GreetingResolver] });
// OR
// For more control on the underlying express app (the server is not automatically started):
const server = superServer.setup({
graphQLServerOptions: {
buildSchemaOptions: {
resolvers: [GreetingResolver],
},
},
});
// Express configuration
superServer.getExpressApp().get('/yo', (req, res) => res.send('Yo'));
// Manually start the server
server.listen(process.env.PORT);
Some configuration can only be changed by env vars:
| Name | Default | Description |
|---|---|---|
| PORT | 3000 |
Server port. |
| ALLOWED_DOMAINS | /http:\/\/localhost.*/ |
CORS whitelisted domains (separated using a comma). |
| SSL_REDIRECT | false |
Have to be set to true to redirect any http request to https. |
For the @boilerz/logger
's configuration here the readme.
yarn version
yarn build
yarn publish dist --access public
Generated using TypeDoc


|
src/app/StartApp/welcome/WelcomeView/welcome.component.ts
|
component |
WelcomeComponent |
0 %
(0/3)
|
|
src/app/StartApp/welcome/start/header/header.component.ts
|
component |
HeaderComponent |
0 %
(0/4)
|
|
src/app/StartApp/welcome/start/header/header.component.ts
|
variable |
buttonName |
0 %
(0/1)
|
|
src/app/StartApp/welcome/start/simulator/jog/jog.component.ts
|
component |
JogComponent |
0 %
(0/22)
|
|
src/app/StartApp/welcome/start/simulator/jog/jog.component.ts
|
injectable |
JogComponent |
0 %
(0/21)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/active-tool/active-tool.component.ts
|
component |
ActiveToolComponent |
0 %
(0/7)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/active-tool/carussel/carussel.component.ts
|
component |
CarusselComponent |
0 %
(0/5)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/mem.component.ts
|
component |
MemComponent |
0 %
(0/8)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/toolpanel/toolpanel.component.ts
|
component |
ToolpanelComponent |
0 %
(0/12)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/wrapper-panels/edit-panel/edit-panel.component.ts
|
component |
EditPanelComponent |
0 %
(0/10)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/wrapper-panels/mdi/mdi.component.ts
|
component |
MdiComponent |
0 %
(0/5)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/wrapper-panels/ofset/ofset.component.ts
|
component |
OfsetComponent |
0 %
(0/3)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/wrapper-panels/program-list/program-list.component.ts
|
component |
ProgramListComponent |
0 %
(0/4)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/wrapper-panels/program-list/program-list.component.ts
|
interface |
Program |
0 %
(0/4)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/wrapper-panels/wrapper-panels.component.ts
|
component |
WrapperPanelsComponent |
0 %
(0/11)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/mem/wrapper-panels/zero-ret/zero-ret.component.ts
|
component |
ZeroRetComponent |
0 %
(0/7)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/panel-wrapper.component.ts
|
component |
PanelWrapperComponent |
0 %
(0/4)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/scene/camera1.ts
|
class |
Camera1 |
0 %
(0/51)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/scene/events-buttons.ts
|
class |
EventsButtons |
0 %
(0/91)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/scene/init.ts
|
class |
Init |
0 %
(0/25)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/scene/scene.component.ts
|
component |
SceneComponent |
0 %
(0/89)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/scene/scene.component.ts
|
injectable |
SceneComponent |
0 %
(0/425)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/scene/scene1.ts
|
class |
Scene1 |
0 %
(0/35)
|
|
src/app/StartApp/welcome/start/simulator/panel-wrapper/scene/shapes.ts
|
class |
Shapes |
0 %
(0/209)
|
|
src/app/StartApp/welcome/start/start/start.component.ts
|
component |
StartComponent |
0 %
(0/15)
|
|
src/app/allPanels/active-program/active-program.component.ts
|
component |
ActiveProgramComponent |
0 %
(0/4)
|
|
src/app/allPanels/active-program/active-program.component.ts
|
variable |
programJson |
0 %
(0/1)
|
|
src/app/allPanels/active-program1/active-program1.component.ts
|
component |
ActiveProgram1Component |
0 %
(0/5)
|
|
src/app/allPanels/panels/panel/panel.component.ts
|
component |
PanelComponent |
0 %
(0/17)
|
|
src/app/allPanels/panels/panel/panel.component.ts
|
variable |
dataPanel |
0 %
(0/1)
|
|
src/app/allPanels/panels/panel2/panel2.component.ts
|
component |
Panel2Component |
0 %
(0/11)
|
|
src/app/allPanels/panels/program/program.component.ts
|
component |
ProgramComponent |
0 %
(0/5)
|
|
src/app/allPanels/tools/Tool.ts
|
interface |
Tool |
0 %
(0/2)
|
|
src/app/allPanels/tools/tools.component.ts
|
component |
ToolsComponent |
0 %
(0/8)
|
|
src/app/allPanels/tools/tools.component.ts
|
interface |
Tool |
0 %
(0/2)
|
|
src/app/allPanels/user-panel.ts
|
class |
UserPanel |
0 %
(0/1)
|
|
src/app/app.component.ts
|
component |
AppComponent |
0 %
(0/8)
|
|
src/app/forward-backward.ts
|
variable |
backwardForward |
0 %
(0/1)
|
|
src/app/gcods/gcods.component.ts
|
component |
GcodsComponent |
0 %
(0/3)
|
|
src/app/gcods/gcods.service.ts
|
injectable |
GcodsService |
0 %
(0/2)
|
|
src/app/info/info.component.ts
|
component |
InfoComponent |
0 %
(0/5)
|
|
src/app/inp/inp.component.ts
|
component |
InpComponent |
0 %
(0/5)
|
|
src/app/move-code.service.ts
|
injectable |
MoveCodeService |
0 %
(0/7)
|
|
src/app/scen.service.ts
|
injectable |
ScenService |
0 %
(0/43)
|
|
src/environments/environment.prod.ts
|
variable |
environment |
0 %
(0/1)
|
|
src/environments/environment.ts
|
variable |
environment |
0 %
(0/1)
|


Bullet Journal Beginner Guide: Every thing you need to know, Part1
January 1, 2020 by SHANNON via wellella Blog
So, you wanna know what’s a bullet journal, do you? Maybe you’ve already seen lots of cool bullet journal ideas on Pinterest, or even checked out some YouTube videos, but you’re still not quite sure how to bullet journal.

Don’t worry! Lucky for you, I’ve set up this nifty and thorough bullet journal guide to explain everything you could possibly be wondering about it.
What is a bullet journal?
In the words of bullet journal creator Ryder Carroll, the bullet journal is a “mindfulness practice disguised as a productivity system.”
My simpler bullet journal definition is this: it’s a notebook that keeps you organized using a special system.
The notebook part is simple (use whatever you want), but the system part is what throws people off.
I, like many others before me, found jargon such as Future Log, Signifiers, and Migration to be utterly perplexing. After much reading, I realized that the system is actually simple, practical, and yes – it works.
If you like writing with pen and paper, like making to-do lists, want to improve your habits, or want to get better at not wasting time, a bullet journal will be worth it for you!
If you’re confused about all the funny words bujo-ers use (like bujo), check out my bullet journal glossary post. It’s an explainer that should help you understand the terms and abbreviations commonly used in the planner community.
How To Bullet Journal In 5 Easy Steps
Before you start a bullet journal, you’re gonna need to create a kind of framework. This framework is what makes the bullet journal method work.
The bullet journal method is made up of several different modules:
- a table of contents (the Index Page)
- a yearly overview (the Future Log)
- monthly overview pages (Monthly Logs)
- weekly or daily overview pages (Weekly and Daily Logs)
Step One – Index Page
As mentioned above, the bullet journal index page is like a table of contents, helping you keep track of where things are located in your notebook. In order do to this, you’ll first need to number the pages in your journal.
Once you’ve got numbered pages, you can designate a page or two to use as your index. In the same way that books usually put the table of contents right at the front, most bullet journalers put their index on the first page or two of their journal.
 Later, you’ll fill in this area with the important topics in your journal and what page to find them on.
Pretty spiffy, eh?
Step Two – Future Log
The Future Log gives you an overview of the year ahead. Like a calendar.
So in your Future Log you’ll write down all the birthdays, events, appointments, and other important dates coming in the months ahead.
Here’s another future log example:
Now, you must be wondering, what comes after the future log? I’ll tell you.
It’s your first monthly log. Yay!
Step Three – Monthly Log
The Monthly Log gives you a big-picture view of the month ahead.
A monthly calendar spread is where you can write down all the happenings, events, birthdays, goals, monthly tasks, etc.
You’ll create a new monthly log at the start of each month. If you’re setting up your bullet journal for the first time, during the middle of the month, just make a monthly log for the current month.
The basic set up for the monthly log is to use two facing pages.
On one side, you can put a calendar page. Some people put a list of all the days of the month, some prefer to make a calendar grid. You do you.
Once you’ve created the calendar, just log your upcoming events. You can also add them in as they occur later.
On the facing page, list your goals, objectives, monthly tasks. I like to write down any holidays and special awareness themes for the month here as well.
As you can see if you’ve been following along with these steps, making a bullet journal is not that hard. There’s one more special page to set up.
Step Four – Weekly Log
Okay, so weekly logs were not originally included in the official bullet journal set up.
BUT from what I see, most bullet journalers make them.
It’s useful to see what you’ve got going on for the rest of the week, and to see how far away you are from the weekend, is it not?
To make a weekly log, you can either use a single page, or two facing pages. I recommend starting out with two facing pages. If you find that you still have plenty of blank space after a week, you can cut back to using only one page for the next week.
All you need to do here is write out the days of the week, equally spaced. The typical weekly spread layout is some kind of grid. In the above example I wanted to keep it simple-looking by using only horizontal lines.
Step Five – Daily Log
Daily logs are the bread and butter of bullet journaling. This is where you’ll keep a running list of tasks, events, and notes for the day. It’s kind of like a daily to-do list, but where you also log things you want to remember.
For example, if you have any appointments, meetings, classes, or things you need to get done for the day, write them in your daily log.
The daily log is also a good place to keep track of what happened during the day. If you want to track your water intake, you can write down how many glasses of water you drank. You can log your exercise, reading, what you ate, or any other things you did.
If you’re using a weekly log, you can just do your daily logging in the areas you already wrote out for each day.


THE CREATIVE
THE CREATIVE
PRACTICES
PRACTICES
OF
OF
XANDER
XANDER
NELSON
NELSON
BASH ME
COMMITMENT
EXQUISITE CORPSE
GITHUB


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/another.20timeout.html ---
The perfectoid project currently compiles fine, according to Travis, but if I try it in VS Code I get deterministic timeouts! I have traced the issue back to VS Code feeding -T100000
to Lean (maximum number of memory allocations per task), but Travis not doing this.
If I have code which is timing out with -T100000
does this indicate that something is wrong with the code? Before, we had timeout issues which were fixed by making arbitrary universe changes. Maybe I'll try this now, but in general I am not sure what this means. I've seen my code give typeclass inference errors which could be fixed by changing the max depth, but this is the first time I've seen a timeout issue which could be fixed by changing the parameters.
Oh, I definitely get this when I let tactics go berserk. It's usually solved by splitting things into smaller lemmas.
I have managed to tame the timeouts but I don't think it's a tactic issue.
def presheaf_map {U V : opens (spa A)} (hUV : U ≤ V) : presheaf_value V → presheaf_value U := λ f, ⟨λ rd, let TEMP := f.val in TEMP ⟨rd.val, set.subset.trans rd.2 hUV⟩, -- f.val ⟨rd.val, set.subset.trans rd.2 hUV⟩, -- this times out with lean -T100000 λ rd1 rd2 h, -- I do not particularly want to go into tactic mode right now begin let TEMP2 := f.2 (rational_open_data_subsets.map hUV rd1) (rational_open_data_subsets.map hUV rd2) h, exact TEMP2, -- exact f.2 (rational_open_data... times out -- convert f.2 (rational_open_data... works end⟩
This should be a purely term mode proof. The first problem is that f.val ⟨rd.val, set.subset.trans rd.2 hUV⟩
times out when applied directly; this let
hack fixes the first timeout. The second timeout I solve in tactic mode (it's a prop) but it's the same story; a term should work, but exact
fails and it's only convert
or the let
which save us. A convert
can be used with the first timeout too, but this causes errors later in the file for some reason.
I would like to debug this further. I do not know what is going on at all. If this is happening because we have written bad code then I'd like to write better code but I don't know which code is bad. If this is happening because of some other reason I'd still like to know what is going on. I feel a bit helpless at the minute; I have no understanding why the first let
changes anything. @Sebastian Ullrich @Mario Carneiro can either of you make some educated guesses about what is happening?
A completely compiled version of the perfectoid project, all the olean files, with current mathlib master, is available here:
wwwf.imperial.ac.uk/~buzzard/xena/perfectoid_20190513.tar
If you download this, and run lean --make
in src
the command returns very quickly with no output. The project is all compiled and all fine. Now open it in VS Code and in src/Spa.lean
on line 720 there is a timeout, which can be fixed by changing -T100000 to a higher value in VS Code settings. Lean is working far too hard to compile this lemma. Changing f.val ⟨rd.val, set.subset.trans rd.2 hUV⟩,
to let TEMP := f.val in TEMP ⟨rd.val, set.subset.trans rd.2 hUV⟩,
fixes everything.
what is the type of TEMP
?
and f
and ⟨rd.val, set.subset.trans rd.2 hUV⟩
Here's a working term mode proof:
def presheaf_map {U V : opens (spa A)} (hUV : U ≤ V) (f : presheaf_value V) : presheaf_value U := ⟨_, λ rd1 rd2 h, (f.2 (rational_open_data_subsets.map hUV rd1) (rational_open_data_subsets.map hUV rd2) h : _)⟩
But what's going on? How is (blah : _) any different to blah?
This is my actual question. Is the point that your code is somehow better than my code in some intrinsic way -- I should never have written my code the way I wrote it? Or is the problem that I have made some ghastly types and the fact that they're difficult to manipulate is my fault and something should be changed? Or is the problem that Lean is not very good at something and you know how to work around the deficiency? What is actually happening?
(blah : _)
says "ignore the expected type here, figure out the type of blah first and then unify with the goal"
But doesn't (blah)
also say that?
blah
says "use the expected type to elaborate blah
"
usually this is a good thing, but occasionally it gives a bad result
Aah. So the elaboration process of a term usually takes the type of this term into account, and this is a workaround to stop it doing this?
Running Lean with -T200000 succeeds, by the way -- so everything is consistent; this is just, for some reason, a way of making Lean succeed quicker.
I think I figured out the problem (and I guess you could class it as "lean is not very good at something"). If I start with
def presheaf_map {U V : opens (spa A)} (hUV : U ≤ V) (f : presheaf_value V) : presheaf_value U := begin refine ⟨λ rd, _, _⟩, have := f.val, end
I see that the goal has type r_o_d_completion (rd.val)
, and the have
has type Π (rd : rational_open_data_subsets V), r_o_d_completion (rd.val)
. The obvious solution is to plug rd
into f.val
but this doesn't work because rd : rational_open_data_subsets U
instead
I am deeply sorry about r_o_d_completion
by the way. I got sick of typing rational_open_data
. It's on my job list to change it to something more sensible.
But the problem is that when you use refine f.val _
here lean thinks "okay, let's make r_o_d_completion (rd.val) =?= r_o_d_completion (?m.val)
. I know, let's try to make all the arguments to r_o_d_completion
the same and rd =?= ?m
. So I have to prove rational_open_data_subsets U =?= rational_open_data_subsets V
." Lean then gets lost unfolding your tower of definitions, hoping that U doesn't actually appear in the definition so that rational_open_data_subsets U
is defeq to rational_open_data_subsets V
but this doesn't work because
rd : rational_open_data_subsets U
instead
Right, that's what all the set.subset.trans rd.2 hUV
is about.
Oh you have maybe completely debugged this. Many thanks as ever! Did you use some trace tools or was this just pure thought? I think it is worth my while thinking about what you're saying here. This is a trick I don't know yet.
This is often the place where the :_
trick works
I usually see this when you use congr_arg
, which is another place where the heuristic f x =?= g y => f =?= g /\ x =?= y
leads lean astray
I knew the maths I was formalising in the project (although as Patrick pointed out I didn't know all of the details in several places), but the timeouts were scary. Before we finished the project I was sometimes thinking "you know, Lean actually can't do this can it". I've been forced to wrestle with several timeouts.
But Lean always came through in the end, although the solutions were a bit random.
On line 744 of src/valuation/field.lean
if you change Type u
to Type*
then Lean times out. That was the worst one. I have no idea why.
For that one, I tried
begin refine valuation.completion_extend _, -- try_for 10000 { -- exact valuation.completion_extend (valuation_field.canonical_valuation v) -- } end
and it says
invalid type ascription, term has type valuation (ring_completion (valued_ring ?m_3 ?m_5)) ?m_1 : Type (max ? ?) but is expected to have type valuation (ring_completion (valuation_field v)) (value_group v) : Type ?
what is the relation between valuation_field
and valued_ring
?
I see, valued_ring
is a wrapper. This is not being very nice to lean, it has no idea what to unwrap here. I'm guessing valuation_field
is much more complicated, so lean's heuristics say to unfold the more complicated one and it gets lost
That wrapper caused us problems.
It's funny that changing the universe made it work though.
In fact even with_zero
caused us problems (a wrapper for option
) -- we used with_zero
a lot and at some point we seriously considered redefining it by just copying some option
code; the option
kept leaking out.
have you tried printing the definition? It makes me weep to see
The definition of what?
noncomputable def valuation_on_completion {R : Type u} [comm_ring R] (v : valuation R Γ) : valuation (ring_completion (valuation.valuation_field v)) (value_group v) := valuation.completion_extend (valuation_field.canonical_valuation v) set_option pp.all true #print valuation_on_completion
oh, actually that's not so bad
this version looks much worse
begin have := valuation.completion_extend (valuation_field.canonical_valuation v), dunfold valued_ring at this, exact this end
I need a deduplicating pp printer
I don't really understand what you're saying.
These printouts always make expressions look worse than they are
We just typed in normal maths
but if expressions are much much worse under the hood than they appear then that's a bad sign
and stuff like timeouts is just the symptom
the moral of the story is "don't make lean work too hard"
sometimes you accidentally ask lean to do something silly and then you get a timeout for no reason
We're just extending a valuation on a ring to a valuation on its completion. What's not to like?
You're saying we should be looking at our terms to see if any of them are getting suspiciously large?
But what can we do to stop this happening?
You shouldn't have unfolded our wrapper!
The reason this happened was the first error message I posted:
invalid type ascription, term has type valuation (ring_completion (valued_ring ?m_3 ?m_5)) ?m_1 : Type (max ? ?) but is expected to have type valuation (ring_completion (valuation_field v)) (value_group v) : Type ?
I think the problem is not actually valued_ring
itself but all the instances on it
valuation_field
has a bunch of instances, and valued_ring
has different instances, and a lot of unfolding needs to happen to see they are the same
Why are you applying a theorem which isn't obviously applicable?
what's the logic here? How does the stuff on valuation_field
relate to valued_ring
?
A valued ring is a ring together with a valuation. This valuation induces a topology, etc...
A valuation field is a particular example.
maybe you need a typeclass for that
rather than a type constructor
i.e. valued_ring R v
is a prop assertion that says that a topological ring is generated by a valuation
that way you can assert that valuation_field
is a valued ring, even though it isn't literally constructed as "adjoin this valuation to the ring"
aka stricklandize it
Or we change it to valued_ring.mk
? And we have class
class valued_ring (R : Type*) [ring R] := (v : valuation R Γ)
I was going to say that, and then I realized that the gamma will give you problems
Sorry, my exam just finished and I had to pick up several hundred pieces of paper
With a random ring R there are lots of valuations, so lots of topologies. But given a valuation v we wanted a topology on R so we went with a wrapper because topological_space is a class I guess.
invalid type ascription, term has type valuation (ring_completion (valued_ring ?m_3 ?m_5)) ?m_1 : Type (max ? ?) but is expected to have type valuation (ring_completion (valuation_field v)) (value_group v) : Type ?
valued_ring ?m_3 ?m_5
is just by definition ?m_3
but this is all about topology, and I can't put a topology on ?m_3
because it depends on ?m_5
We mathematicians need to learn the right way to think about this stuff.
@Mario Carneiro Can you formulate a general principal here? Why is valued_ring
a bad type wrapper, but multiplicative
a good one?
but if expressions are much much worse under the hood than they appear then that's a bad sign
Do you mean "much worse after you've unfolded absolutely everything" or something else?
I mean much worse explicitly, before any unfolding
or after any unfolding that needs to be done in the moment
like unfolding valued_ring
.
valued_ring
is not a bad type wrapper, but it's not sufficient for all things. In particular, this is the same problem we've seen before with localization
. Sometimes you want to perform the construction, and sometimes you want to say that an independently constructed type is isomorphic to the construction
quotient
is another example of this
It doesn't apply if the type isn't actually quotient bla
I was going to say that, and then I realized that the gamma will give you problems
Because of universe issues or because we just need to input it directly with
class valued_ring (R : Type u) [ring R] := (Γ : Type u) [totally_ordered_group Γ] -- or whatever we called it (v : valuation R Γ)
In this case you have valued_ring R v
, the construction, and you want to apply it to valuation_field v
, which after unfolding is not defined as valued_ring bla bla
There's something a bit wrong. Those v's are perhaps not the same.
valuation_field v
has got a valuation on it but it's not v
right, I'm not saying they are
Oh Ok
No, you're supposed to be unfolding valued_ring here, not valuation_field
I'm saying that valuation_field v =?= valued_ring ?m1 ?m2
doesn't have a solution by unfolding valuation_field
Right!
Unfold the other one.
Even if you unfold valued_ring
here, it doesn't solve the problem of all the instances
I think that you're saying that if we're going to use a wrapper type, then we must be very careful to wrap everything up.
valued_ring
has a bunch of instances on it, a uniform structure and so on - does valuation_field v
have the same structure?
No
then you shouldn't apply this theorem
Hmm...we could put those structures on it.
We wrote the wrapper because for a general ring R and a general valuation v, we definitely don't want R to inherit the uniform structure from v, because often R will be fixed and v will change
My guess is you want to prove is_valued_ring (valuation_field v) (valuation_field.canonical_valuation v)
valuation_field v
is exactly the point where we've manipulated the ring so much that now we'll never put another valuation on it.
None of this conversation is about mathematics, in some sense.
It's proof engineering stuff
So I'm a beginner here.
Yes exactly.
You can have valued_ring R v
as before, and prove is_valued_ring (valued_ring R v) v
So we keep the wrapper?
and then completion_extend
has the type valuation (ring_completion K) Γ
where is_valued_ring K v
I don't know if you need the wrapper, but I imagine that sometimes you just have a ring and need to put a valuation on it
rather than asserting that a pre-existing topological ring is generated by a valuation
That's right.
so you want both
In fact I think that always we just have the ring and need to put a topology on it coming from a valuation.
That's why we used a wrapper -- because the valuation can vary, but topological_space is a class.
I think that's what you thought originally and that's why the code looks like it does, but it turns out not to be the case
because valuation_field
is clearly not of that form
It is of that form mathematically
But not Lean-ny
valuation_field was a field that didn't have a valuation for most of the projects, and then I realised far too late (because I never wrote a proper roadmap) that we needed a topology on it.
and that's what is_valued_ring
is for, to say "this ring is generated by this valuation"
You might also consider writing valuation_field
so it has the form valued_ring bla bla
, but that will affect other things
Then Patrick found the part of Bourbaki that did what we wanted, and worked in what a library-builder would say was the correct generality: given a valuation on a ring, the ring gets a topology, and the valuation extends to the completion of the ring.
I guess an alternative would be to rename valuation_field
to valuation_field.aux
and then define valuation_field
as valued_ring (valuation_field_aux _) _
I thought about that too, but there are some nontrivial theorems here about how the topological ring structure is preserved
But I guess that Mario is saying that the predicate approach is better (because more flexible?)
I suspect that the only time we ever apply the valued_ring stuff is to valuation_field v
(which is a field), however there were a bunch of general theorems about the topology on a ring induced by a valuation in Bourbaki and Patrick formalised those.
the predicate approach means that the instances are not impacted - they are just the valuation_field
instances
So Patrick was faced with the dilemma of having a ring R, and a valuation v on R, and he wanted to talk about the induced topology on R. So the wrapper was born.
This was almost certainly the correct generality for Bourbaki. But in retrospect it was more than we needed for our application.
Thanks for all these comments. I'll digest them slowly.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


My Projects
1. First time
This is the page you find yourself in immediately after login. If you read this
text first time ever, you are probably new to jsCoFE, just logged in with temporary
password sent to you after registration. Then the first thing you want to do is
to change your temporary password for something memorisable. You do not have
to do that -- your temporary password won't expire -- but if you do, look for
the Menu icon:
in the top-left corner of the page. Click on it, then choose "My Account"
from the dropdown menu, and you will be presented with your account settings.
Choose and type your new password in there, press button
"Update my account", and job's done. You will be then taken to jsCoFE's
home page in order to login with your new password.
2. Projects
In jsCoFE, your work is arranged in Projects. There is no strict rules how to
use them, but a good practice would be to put all work, related to a particular
protein, into one Project. Projects start with uploading experimental data and
subsequent jobs along the following line:
data processing
phasing (MR or EP)
density modification
model building
refinement
validation and deposition
which should result in structure solved.
3. Getting started
The page shows the list of projects, which is empty at start. Press "
Add"
button in the button line above the list, and create your first project. You will
need to specify short project name, and a more descriptive title in the dialog
appeared, for example:
then press "Add" and see the new project appeared in the list.
The project list is both sortable (use controls found in column titles) and
selectable. In order to open a particular Project, select it and press
"Open" button on top of the list or, alternatively, just double-click
on the project line.
You can delete your projects as well: simply select unwanted project in the list
and press "Delete" button. Do this with due care: once deleted, projects
cannot be restored.
4. Project export and import
Using the "
Export" button, you can download the selected project as a
compressed TAR archive. Exported archives can be uploaded later to your jsCoFE
account using the "
Import" button above the project list.
Exporting projects may be needed if there is no disk space left in your account,
personal archival or for transferring data to another jsCoFE setup. Beware that
projects usually grow to a considerable size, from 100s MBs to few GBs. You will
be advised about the project size before downloading.
5. After work
Whenever you wish to end working with jsCoFE, please do logout. This can
be done through the Menu or by clicking on the exit button:
in the top-right corner. Doing so will ensure that all your data and projects
will be found in exactly the same state as you left them. Do not worry about
jobs still running: they will not be terminated if you quit your working session.
Note that jsCoFE does not support multiple logins of the same user. Each login
will forcefully terminate any other session of the same user still open.


--- layout: default title: About Data Stories ---
The following key combinations are supported within the SPARQL Editor (YASQE). We sometimes use the notion of a group, wich is either one word (space-delimited sequence of non-space characters), a sequences of multiple whitespace characters, or one newline.
| Key combination | Behavior |
|---|---|
Alt + Left | Move the cursor to the beginning of the current line. |
Alt + Right | Move the cursor to the end of the current line. |
Alt + U | Redo the last change within the current selection. |
Ctrl + Backspace | Delete to the beginning of the group before the cursor. |
Ctrl + Delete | Delete to the beginning of the group after the cursor. |
Ctrl + End | Move the cursor to the end of the query. |
Ctrl + Home | Move the cursor to the start of the query. |
Ctrl + Left | Move the cursor to the left of the group before the cursor. |
Ctrl + Right | Move the cursor to the right of the group the cursor. |
Ctrl + [ | Decrements the indentation for the current line or the lines involved in the current selection. |
Ctrl + ] | Increments the indentation for the current line or the lines involved in the current selection. |
Ctrl + / | Toggles on/off the commenting of the current line or the lines involved in the current selection. |
Ctrl + A | Select the whole query. |
Ctrl + D | Deletes the current line or all lines involved in the current selection. |
Ctrl + U | Unfo the last change within the current selection. |
Ctrl + Y | Redo the last undone edit action. |
Ctrl + Z | Undo the last edit action. |
Ctrl + Shift + F | Auto-formats the whole query or the lines involved in the current selection. |
Shift + Tab | Auto-indents the current line or the lines involved in the current selection. |
Tab | Indents the current line or the lines involved in the current selection. |
The following SPARQL variable names are used in the 2D visualization:
| Variable name | Purpose |
|---|---|
?shape | An arbitrary variable name that gets bound to literals with datatype geo:wktLiteral , and whose name is the prefix of the other variable names in this table. |
?shapeColor | The color of the shape bound to ?shape . Either a CSS3 color name, an RGB color code, or a value between 0.0 and 1.0 in combination with the name of a color palette. The color palettes to choose from are (1) the ones defined by colormap or (2) the ones defined by Color Brewer. |
?shapeLabel | The text or HTML content of popups that appear when clicking the shape bound to ?shape . |
In addition to the variables supported by SPARQL 2D, the following SPARQL variable names are used in the 3D visualization:
| Variable name | Purpose |
|---|---|
?shapeHeight | The height in meters of the 2.5D shape that is based on the 2D shape that is bound to ?shape . |
?shapeOffset | The height in meters at which the 2.5D shape that is based on the 2D shape that is bound to ?shape starts. |
The following variable names are used in the gallery visualization:
| Variable name | Purpose |
|---|---|
?widget | A plain string or a literal with datatype IRI rdf:HTML , which is used as the content of the widgets that are displayed in gallery rows. |
It is often useful to create HTML snippets within a SPARQL query: this allows for moderately intuitive and human-readable visualizations of query results (e.g., in SPARQL Gallery, SPARQL 2D, or SPARQL 3D). Perfoming all string insertions in SPARQL works, but results in queries that are difficult to read and maintain:
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns# >
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema# >
prefix rvo: <https://data.labs.pdok.nl/def/ >
select * {
[ a rvo:Land;
rdfs:label ?land;
rvo:hoofdstad/rdfs:label ?hoofdstad;
rvo:munteenheid/rdfs:label ?munteenheid;
rvo:vlag ?vlag].
bind(strdt(concat(
'
',str(?land),'
',
'
',
'',
'
In ',str(?land),' hanteert men als munteenheid de ',str(?munteenheid),'. De hoofdstad van ',str(?land),' is ',str(?hoofdstad),'.
',
'
'), rdf:HTML, ?widget))
}
YASGUI introduces SPARQL Templating, which allows one large string to
be used, rather than a large number of small strings that are
arguments to concat
. SPARQL variables ?abc
can be inserted into
this one large string by using the {{abc}}
templating notation.
In order for a SPARQL variable to be used in this way, it must occur
in the outer projection, because YASGUI (and not the server) performs
template substitution.
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns# >
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema# >
prefix rvo: <https://data.labs.pdok.nl/def/ >
select * {
[ a rvo:Land;
rdfs:label ?land;
rvo:hoofdstad/rdfs:label ?hoofdstad;
rvo:munteenheid/rdfs:label ?munteenheid;
rvo:vlag ?vlag].
bind('''

{{land}}

In {{land}} hanteert men als munteenheid de {{munteenheid}}. De hoofdstad van {{land}} is {{hoofdstad}}.

'''^^rdf:HTML as ?widget)
}
Data Stories is a way to publish SPARQL query results in a human-readable way.
Data Stories defines the following two HTML elements:

: The tag that contains zero or more <query>
tags and that implements the Data Story.<query>
: The tag that implements one query within the Data Story.The following attributes are defined on a data story element:
data-endpoint
: The URI of the SPARQL endpoint against which all
queries in the Data Story are executed.data-output
: The output format that is used to display SPARQL
result sets in. The following values are supported:boolean
: Shows the result of an ask
query.error
: TODOgallery
: Shows HTML widgets in card rows.gchart
: Shows a UI for selecting numeric properties in order
to generate various diagrams.geo
: Shows GeoSPARQL results on a 2D map.geo3d
: Shows GeoSPARQL results on a 3D map.pivot
: Shows a UI for selecting numeric properties in order to
generate various diagrams and pivot tables.raw
: The textual content of the HTTP reply body. For example,
the SPARQL result set serialized in XML, JSON, or CSV.table
: Shows the results in rows of an HTML table. This is
the default value.
The following attributes are defined on the query
element:
data-config="URI"
: A URI that encodes a query together with the
configuration of a specific view. These URIs can be created
within the SPARQL IDE.data-endpoint="URI"
: The URI of the SPARQL endpoint against
which a particular query is evaluated. When absent, the value of
this attribute on the

tag is used.data-query-ref="URI"
: An absolute or relative URI to a file that
stores a SPARQL query.data-output="VALUE"
: The output format that is used to display
the SPARQL result set. When absent, the value of this attribute
on the

tag is used. See the documentation
of the Story element for the supported values.data-show-query
: Used to show the query directly to the user.


--- title: 0.1.1 ---
Eventually, ISHML will address all aspects of creating interactive fiction. For now, though, ISHML is just a really flexible and powerful parser that integrates easily into your projects.


Public Member Functions |
| | SHAiButtonCoprVM (byte[] RomID, int l_signPageNumber, int l_authPageNumber, int l_wspcPageNumber, int l_version, int l_encCode, byte l_serviceFileExt, byte[] l_serviceFilename, byte[] l_providerName, byte[] l_bindData, byte[] l_bindCode, byte[] l_auxData, byte[] l_initialSignature, byte[] l_signingChlg, byte[] l_signingSecret, byte[] l_authSecret) throws OneWireException, OneWireIOException |
| | SHAiButtonCoprVM (String filename) throws OneWireException, OneWireIOException |
| | SHAiButtonCoprVM (String filename, byte[] sign_secret, byte[] auth_secret) throws OneWireException, OneWireIOException |
| | SHAiButtonCoprVM (OneWireContainer owc, String filename) throws OneWireException, OneWireIOException |
| | SHAiButtonCoprVM (OneWireContainer owc, String filename, byte[] sign_secret, byte[] auth_secret) throws OneWireException, OneWireIOException |
| | SHAiButtonCoprVM (OneWireContainer18 owc, String filename, byte[] sign_secret, byte[] auth_secret) throws OneWireException, OneWireIOException |
| boolean | save (String filename, boolean saveSecretData) throws OneWireException, OneWireIOException |
| boolean | save (OneWireContainer owc, String filename, boolean saveSecretData) throws OneWireException, OneWireIOException |
| boolean | load (String filename) |
| boolean | load (OneWireContainer owc, String filename) |
| boolean | load (OneWireContainer18 owc, String filename) |
| boolean | createDataSignature (byte[] accountData, byte[] signScratchpad, byte[] mac_buffer, int macStart) throws OneWireException, OneWireIOException |
| synchronized boolean | generateChallenge (int offset, byte[] ch, int start) throws OneWireIOException, OneWireException |
| boolean | verifyAuthentication (byte[] fullBindCode, byte[] pageData, byte[] scratchpad, byte[] verify_mac, byte authCmd) throws OneWireIOException, OneWireException |
| boolean | createDataSignatureAuth (byte[] accountData, byte[] signScratchpad, byte[] mac_buffer, int macStart, byte[] fullBindCode) throws OneWireException, OneWireIOException |
| boolean | verifySignature (byte[] pageData, byte[] scratchpad, byte[] verify_mac) throws OneWireIOException, OneWireException |
| synchronized boolean | bindSecretToiButton (int pageNum, byte[] bindData, byte[] bindCode, int secretNum) |
| boolean | installMasterSecret (int pageNum, byte[] secret, int secretNum) |
| String | toString () |
| | Returns a string representing the 1-Wire address of this SHAiButton.
|
Protected Attributes |
|
byte[][] | secretPage = new byte[8][8] |
| | 8 8-byte Secrets for this simulated SHAiButton
|
|
byte[] | address = new byte[8] |
| | 1-Wire Address for this simulated device
|
Class for simulating an instance of a SHA iButton Coprocessor involved in SHA Transactions. The Coprocessor is used for digitally signing transaction data as well as generating random challenges for users and verifying their response.
With this class, no DS1963S SHA iButton is necessary for the coprocessor in SHA Transactions. The simulated Coprocessor iButton verifies signatures and signs data for User iButtons.
This class makes use of several performance enhancements for TINI. For instance, most methods are synchronized
to access instance variable byte arrays rather than creating new byte arrays every time a transaction is performed. This could hurt performance in multi-threaded applications, but the usefulness of having several threads contending to talk to a single iButton is questionable since the methods in com.dalsemi.onewire.adapter.DSPortAdapter
beginExclusive(boolean)
and endExclusive()
should be used.
- See also:
- SHATransaction
-
SHAiButtonUser
-
SHAiButtonCopr
- Version:
- 1.00
- Author:
- SKH
| synchronized boolean bindSecretToiButton |
( |
int |
pageNum, |
|
|
byte[] |
bindData, |
|
|
byte[] |
bindCode, |
|
|
int |
secretNum |
|
) |
| |
Binds an installed secret to this virtual DS1963S by using well-known binding data and this DS1963S's (unique?) address. This makes the secret unique for this iButton. Coprocessor iButtons use this method to recreate the iButton's secret to verify authentication. Roving iButtons use this method to finalize their secret keys.
Note that unlike in the installMasterSecret()
method, the page number does not need to be equivalent to the secret_number
modulo 8. The new secret (installed secret + binding code) is generated from this page but can be copied into another secret. User iButtons should bind to the same page the secret was installed on. Coprocessor iButtons must copy to a new secret to preserve the general system authentication secret.
The binding should be either 7 bytes long or 15 bytes long. A 15-length byte
array is unaltered and placed in the scratchpad for the binding. A 7-length byte
array is combined with the page number and DS1963S unique address and then placed in the scratchpad. Coprocessors should use a pre-formatted 15-length byte
array. User iButtons should let the method format for them (i.e. use the 7-length byte
array option).
- Parameters:
-
| page | the page number that has the master secret already installed |
| bind_data | 32 bytes of binding data used to bind the iButton to the system |
| bind_code | the 7-byte or 15-byte binding code |
| secret_number | secret number to copy the resulting secret to |
- Returns:
true
if successful
- See also:
- installMasterSecret(int,byte[],int)
Given a 32-byte array for page data and a 32-byte array for scratchpad content, this function will create a 20-byte signature for the data based on SHA-1. The format of the calculation of the data signature is as follows: First 4-bytes of signing secret, 32-bytes of accountData, 12 bytes of scratchpad data starting at index 8, last 4-bytes of signing secret, 3 bytes of scratchpad data starting at index 20, and the rest is padding as specified for standard SHA-1. This is all laid out, in detail, in the DS1963S data sheet.
The resulting 20-byte signature is copied into mac_buffer
starting at macStart
. If you're updating a signature that already exists in the accountData array, it is acceptable to call the method like so:
copr.createDataSignature(accountData, spad, accountData, 8);
assuming that the signature starts at index 8 of the accountData array.
- Parameters:
-
| accountData | the 32-byte data page for which the signature is generated. |
| signScratchpad | the 32-byte scratchpad contents for which the signature is generated. This will contain parameters such as the user's write cycle counter for the page, the user's 1-wire address, and the page number where account data is stored. |
| mac_buffer | used to return the 20-byte signature generated by signing the page using the coprocessor's system signing secret. |
| macStart | the offset into mac_buffer where copying should start. |
- Returns:
true
if successful, false
if an error occurred (use getLastError()
for more information on the type of error)
- Exceptions:
-
| OneWireIOException | on a 1-Wire communication error such as reading an incorrect CRC from a 1-Wire device. This could be caused by a physical interruption in the 1-Wire Network due to shorts or a newly arriving 1-Wire device issuing a 'presence pulse'. |
| OneWireException | on a communication or setup error with the 1-Wire adapter |
- See also:
- OneWireContainer18.SHAFunction(byte,int)
-
#getLastError()
| boolean createDataSignatureAuth |
( |
byte[] |
accountData, |
|
|
byte[] |
signScratchpad, |
|
|
byte[] |
mac_buffer, |
|
|
int |
macStart, |
|
|
byte[] |
fullBindCode |
|
) |
| throws OneWireException, OneWireIOException |
Creates a data signature, but instead of using the signing secret, it uses the authentication secret, bound for a particular button.
fullBindCode
is ignored by the Coprocessor VM. Instead of binding the secret to the signing page, the coprocessor VM "cheats" and lets you sign the workspace page, where (presumably) the secret is already bound.
- Parameters:
-
| accountData | the 32-byte data page for which the signature is generated. |
| signScratchpad | the 32-byte scratchpad contents for which the signature is generated. This will contain parameters such as the user's write cycle counter for the page, the user's 1-wire address, and the page number where account data is stored. |
| mac_buffer | used to return the 20-byte signature generated by signing the page using the coprocessor's system signing secret. |
| macStart | the offset into mac_buffer where copying should start. |
| fullBindCode | ignored by simulated coprocessor |
- Returns:
true
if successful, false
if an error occurred (use getLastError()
for more information on the type of error)
- Exceptions:
-
| OneWireIOException | on a 1-Wire communication error such as reading an incorrect CRC from a 1-Wire device. This could be caused by a physical interruption in the 1-Wire Network due to shorts or a newly arriving 1-Wire device issuing a 'presence pulse'. |
| OneWireException | on a communication or setup error with the 1-Wire adapter |
- See also:
- OneWireContainer18.SHAFunction(byte,int)
-
createDataSignature(byte[],byte[],byte[],int)
-
#getLastError()
Generates a 3 byte random challenge in the iButton, sufficient to be used as a challenge to be answered by a User iButton. The user answers the challenge with an authenticated read of it's account data.
The DS1963S will generate 20 bytes of pseudo random data, though only 3 bytes are needed for the challenge. Programs can add more 'randomness' by selecting different bytes from the 20 bytes of random data using the offset
parameter.
The random number generator is actually the DS1963S's SHA engine, which requires page data to compute a hash. Select a page number with the page_number
parameter.
- Parameters:
-
| offset | offset into the 20 random bytes to draw random data from (must be in range 0-16) |
| ch | buffer for the challenge to be returned (must be of length 3 or more) |
| start | the starting index into array ch to begin copying the challenge bytes. |
- Returns:
true
if successful, false
if an error occurred (use getLastError()
for more information on the type of error)
- Exceptions:
-
| OneWireIOException | on a 1-Wire communication error such as reading an incorrect CRC from a 1-Wire device. This could be caused by a physical interruption in the 1-Wire Network due to shorts or a newly arriving 1-Wire device issuing a 'presence pulse'. |
| OneWireException | on a communication or setup error with the 1-Wire adapter |
- See also:
- SHAiButtonUser.readAccountData(byte[],int,byte[],int,byte[],int)
-
#getLastError()
| boolean installMasterSecret |
( |
int |
pageNum, |
|
|
byte[] |
secret, |
|
|
int |
secretNum |
|
) |
| |
Installs a secret on this virtual DS1963S. The secret is written in partial phrases of 47 bytes (32 bytes to a memory page, 15 bytes to the scratchpad) and is cumulative until the entire secret is processed. Secrets are associated with a page number. See the datasheet for more information on this association.
In most cases, page
should be equal to secret_number
or secret_number+8
, based on the association of secrets and page numbers. A secret is 8 bytes and there are 8 secrets. These 8 secrets are associated with the first 16 pages of memory.
On TINI, this method will be slightly faster if the secret's length is divisible by 47. However, since secret key generation is a part of initialization, it is probably not necessary.
- Parameters:
-
| page | the page number used to write the partial secrets to |
| secret | the entire secret to be installed |
| secret_number | the secret 'page' to use (0 - 7) |
- Returns:
true
if successful
- See also:
- bindSecretToiButton(int,byte[],byte[],int)
Determines if a SHAiButtonUser
belongs to the system defined by this Coprocessor iButton.See the usage example in this class for initializing a Coprocessor iButton.
The first step in user authentication is to recreate the user's unique secret on the coprocessor button using bindSecretToiButton(int,byte[],byte[],int)
. Then the coprocessor signs the pageData to produce a MAC. If the MAC matches that produced by the user, the user belongs to the system.
The TMEX formatted page with the user's account data is in the 32-byte parameter pageData
. If the verification is successful, the data data signature must still be verified with the verifySignature()
method.
Failure of this method does not necessarily mean that the User iButton does not belong to the system. It is possible that a communication disruption here could cause a CRC error that would be indistinguishable from a failed authentication. However, repeated attempts should reveal whether it was truly a communication problem or a User iButton that does not belong to the system.
- Parameters:
-
| fullBindCode | 15-byte binding code used to recreate user iButtons unique secret in the coprocessor. |
| pageData | 32-byte buffer containing the data page holding the user's account data. |
| scratchpad | the 32-byte scratchpad contents for which the signature is generated. This will contain parameters such as the user's write cycle counter for the page, the user's 1-wire address, and the page number where account data is stored. |
| verify_mac | the 20-byte buffer containing the user's authentication response to the coprocessor's challenge. |
- Returns:
true
if the operation was successful and the user's MAC matches that generated by the coprocessor.
- Exceptions:
-
| OneWireIOException | on a 1-Wire communication error such as reading an incorrect CRC from a 1-Wire device. This could be caused by a physical interruption in the 1-Wire Network due to shorts or a newly arriving 1-Wire device issuing a 'presence pulse'. |
| OneWireException | on a communication or setup error with the 1-Wire adapter |
- See also:
- generateChallenge(int,byte[],int)
-
verifySignature(byte[],byte[],byte[])
-
bindSecretToiButton(int,byte[],byte[],int)
-
OneWireContainer18.SHAFunction(byte,int)
-
OneWireContainer18.matchScratchPad(byte[])
-
#getLastError()


Author: Milten Plescott
GitHub profile: https://github.com/MiltenPlescott
Gothic Damage Calculator repository: https://github.com/MiltenPlescott/gothic-damage-calculator
Contact<EMAIL_ADDRESS>License: LICENSE.txt
Special thanks to WernerTWC for his post about the damage formulas: http://forum.worldofplayers.de/forum/threads/127320-Damage-System?p=2198181#post2198181


Blog: Hunt For The Unique, Stable, Sparse And Fast Feature Learning On Graphs (NIPS 2017).
• Tutorials
Graph is a fundamental but complicated structure to work with from machine learning point of view. Think about it, a machine learning model usually require inputs in some form of mathematical objects like vectors, matrices, real number sequences and then produces the desired outputs. So, the question is how we can convert a graph into a mathematical object that is suitable for performing machine learning tasks such as classification or regression on graphs.
For past one year, I have been working on developing machine learning models for graph(s) in order to solve two specific problems:
1) Graph Classification: Given a collection of graphs and associated graph labels where ( is the number of classes), we need to come up with a learning model or function that can classify or predict the label associated with a graph.
2) Node Classification: Given a graph , where is vertex set, is edge set & is adjacency matrix and labels where associated with each node, our task is to classify or predict the labels on each node. That is, come up a learning function .
In this blog, I’ll mainly focus on graph classification problem but also show how we can leverage this work to perform node label classification as well. The fundamental problem in graph classification is comparing two graph structures. The main hurdle in comparing two graph structures is that we don’t know which node in the first graph corresponds to which node in other graph. This problem is universally known as graph isomorphism problem and so far we know it can only be solved in quasi-polynomial time and that too theoretically. Hence people came up with approximate but polynomial alternatives.
Previous studies on graph classification can be grouped into three main categories.
1) Graph Spectrum 2) Graph Kernels 3) Graph Convolutional Networks.
Graph Spectrum: Our majority work falls under first category and similar to graph kernels in certain aspects. But without going too much into what is graph kernel and graph convolutional network I’ll lay out the ideas behind graph spectrum.
First let’s discuss what spectrum mean? Spectrum is a collection of atomic elements (say in form of a set or vector or other mathematical object) to represent objects belonging to the same class (here class of objects could be an electrical signal, an audio signal or a chemical compound). For example, time series signal has a frequency spectrum. The importance of frequency spectrum is that one can recover the whole original signal from its frequency spectrum. Secondly from learning point of view, spectrum gives us a convenient and rich way to compare the similarity between two signals.
Now, the question is does graph has a spectrum? And if so, what are its atomic elements?
The most common graph spectrum you may heard of is graph Laplacian eigenvalue spectrum, where atomic elements are eigenvalues of graph Laplacian matrix. There are two more powerful graph spectrums based on group theory: Skew Spectrum and Graphlet Spectrum. The best thing about graph spectrum is that it atomic elements are solely depends upon the structure of the graph and thus invariant to permutation of graph vertex labels – a very important property desired from learning point of view.
We propose a new graph spectrum which is conceptually simple to understand but at the same time powerful enough as I’ll try to convince. Our Idea: Graph atomic structure (or spectrum) is encoded in the multiset of all nodes pairwise distances.
But what distance one should consider on a Graph?
is based on graph Laplacian spectral properties. Here & is Laplacian eigenvector and eigenvalue respectively.
So what’s special about this family of distance? Depending upon , can capture different type of information about graph sub-structures.
Elements Encode Local Structure Information: For (), one can show that takes only -hop local neighborhood information.
Elements Encode Global Structure Information: For (), one can show that captures global structure information.
Some Known Graph Distances Can Be Derived From .
- Setting yields is harmonic or effective resistance distance.
- Setting yields biharmonic distance.
- Setting yields heat diffusion distance.
Theorem 1 (Uniqueness of ): The -spectral distance matrix uniquely determines the underlying graph (up to graph isomorphism), and each graph has a unique (up to permutation). More precisely, two undirected, weighted (and connected) graphs and have the same based distance matrix up to permutation, i.e., for some permutation matrix , if and only if the two graphs are isomorphic.
Implications: One of the consequence of Theorem is that the based on multiset of is invariant under the permutation of graph vertex labels. Unfortunately, it is possible that the multiset of some members can be same for non-isomorphic graphs (otherwise, we would have a polynomial time algorithm for solving graph isomorphism problem!). However, there is lot of HOPE. It is known that all non-isomorphic graphs with less than nine vertices have unique multisets of harmonic distance. While, for nine & ten vertex (simple) graphs, we have exactly & pairs of non-isomorphic graphs (out of total & graphs) with the same harmonic spectra. These examples show that there are significantly very low numbers of non-unique harmonic spectrums. Moreover, we empirically found that the biharmonic distance has all unique multisets for at-least upto ten vertices ( million graphs) and we couldn’t find any non-isomorphic graphs with the same biharmonic multisets. Further, we have the following theorem regarding the uniqueness of .
Theorem 2 (Uniqueness of Graph Harmonic Spectrum): Let be a graph of size with an unweighted adjacency matrix . Then, if two graphs and have the same number of nodes but different number of edges, i.e, but , then with respect to the harmonic distance multiset, .
Theorem 3 (Eigenfunction Stability of ): Let be the change in distance with respect to change in weight of any single edge on the graph. Then, for any vertex pair is bounded with respect to the function of eigenvalue as follows,
Implications: Decreasing function of (such as ) are more stable.
Conjecture (Sparsity of Graph Spectrum): For any graph , let represents the number of unique elements present in the multiset of , computed on an unweighted graph based on some monotonic decreasing function. Then, the following holds,
Implications: Harmonic Spectrum produce the most sparse features.
Feature Space of Harmonic and Biharmonic Spectrum
Lastly, one can show that the worst case complexity of computing is .
In the end, we take the histogram of spectrum to construct the graph feature vector. Overall our hunt leads to the harmonic distance as an ideal member of family for extracting graph features.
References:
- Saurabh Verma, Zhi-Li Zhang. Hunt For The Unique, Stable, Sparse And Fast Feature Learning On Graphs. In 31st Conference on Neural Information Processing Systems (NIPS 2017). [PDF]


FEATURED PRODUCTS
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$105.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$110.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$100.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$35.00
Sale
-6%
-6%
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$320.00
$340.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$115.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$120.00
Sale
-56%
-56%
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$40.00
$90.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$45.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$130.00
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$135.00
New
Sale
-35%
-35%
Silver, metallic-blue and metallic-lavender silk-blend jacquard, graphic pattern, pleated ruffle along collar, long sleeves with button-fastening cuffs, buckle-fastening silver skinny belt, large pleated rosettes at hips. Dry clean. Zip and hook fastening at back. 100% silk. Specialist clean.
$85.00
$130.00


48.Laabs, B. J. C., Munroe, J. S., Best, L. C. & Caffee, M. W. Timing of the last glaciation
and subsequent deglaciation in the Ruby Mountains, Great Basin, USA.
Earth and Planetary Science Letters361, 16–25,
http://dx.doi.org/10.1016/j.epsl.2012.11.018 (2013).


Surviving the Wilderness - The Field Guide
Fortunately, our hot air balloon extravaganza included a planned meal at our landing point so we happened
to have a pre-packed lunch. Unfortunately, pre-packed lunches only last so long and we soon came to realize the
sticky situation we were in. Fortunately, our interest in forestry meant we had tucked away our handy-dandy
field guide packed with helpful knowledge of edible plants in our wicker basket. Unfortunately, the field guide
was in Spanish. Fortunately, we were both equipped with AP Spanish knowledge and able to muddle our way through
the language barrier to understand some of the book (and by muddle, we mean use pictures).
Thus, we decided to ration our meager portion of commercially packaged durable processed foods and
scavenge around for edible fruits and other plants. We were careful to avoid mushrooms (because those poisonous
mushrooms sure are good at looking like edible ones, sneaky little fungi) and found ourselves snacking on things
like dandelions and assorted berries.


[gecode-users] Freeze with MSVC 2015 optimized build
Christian Schulte
cschulte at kth.se
Thu Sep 3 11:00:59 CEST 2015
Hi,
I am travelling right now and cannot look into the issue right now.
Building with Qt is easy: I just build Qt myself (there is Qt doc how to do
that) and then use that build by setting the path accordingly (pointing to
%QTDIR%/base/bin). I do that as I have Qt builds for all platforms we run
tests on...
Then everything works like a charm.
You need to patient, though, when building Qt.
Cheers
Christian
--
Christian Schulte, www.gecode.org/~schulte
Professor of Computer Science, KTH, cschulte at kth.se
Expert Researcher, SICS, cschulte at sics.se
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of Filip Konvicka
Sent: Thursday, September 3, 2015 10:50 AM
To: users at gecode.org
Subject: [gecode-users] Freeze with MSVC 2015 optimized build
Hi,
I'm having issues with the trunk version of Gecode compiled with MSVC
2015 RTM. The "Release" build seems to get stuck on the attached simple test
case. The "Debug" version of the same (configured with --enable-debug), as
well as the official 4.4.0 distribution compiled with MSVC 2013 x64 seem to
work without issue.
In the test case source code there is a constant "8686.9666660000003".
Changing it to "8686" seems to fix the problem - but even "8686.9" makes dfs
freeze. It also seems that it is the branching strategy
'FLOAT_VAL_SPLIT_MAX' that is causing problems.
I have built Gecode using my usual setup (the environment is set up for the
"xp" compiler toolset) - in the 2015 x64 command prompt I run:
set "INCLUDE=%ProgramFiles(x86)%\Microsoft
SDKs\Windows\7.1A\Include;%INCLUDE%"
set "PATH=%ProgramFiles(x86)%\Microsoft SDKs\Windows\7.1A\Bin;%PATH%"
set "LIB=%ProgramFiles(x86)%\Microsoft SDKs\Windows\7.1A\Lib\x64;%LIB%"
set "CL=/D_USING_V110_SDK71_"
set "LINK=/SUBSYSTEM:CONSOLE,5.02"
C:\cygwin\cygwin
cd /cygdrive/c/build/gecode
./configure --disable-examples --disable-qt --disable-gist
--disable-flatzinc --prefix=`pwd`/x64rel make -j7 install
As you may notice I'm building without Gist so I could not easily check the
progress of the search; as far as I could tell from the callstack there
seems to be some kind of loop but I'm not sure how tight it is.
I'm now trying to get Qt and build with it but so far I'm struggling with
that (is there a howto on building with Qt on Windows?)
Thanks for any hints,
Filip
More information about the users
mailing list


sigmonster
`Prev `__
S
`Next `__
--------------
**sigmonster**: n.
[common] A beast that randomly chooses one of a selection of signatures
for appending to mail and news messages. The creature is most often
mentioned directly when it has been in particularly good form and
selected a signature appropriate to the topic being discussed; the
construction “P.S.: good sigmonster, have a cookie” is not uncommon.
While the are sigmonster programs floating around on the net, most
hackers who keep one use a silly little Perl or Python script that they
threw together in the middle of the night under the influence of far too
much caffeine.
--------------
+------------------------------+----------------------------+------------------------------------------+
| `Prev `__ | `Up <../S.html>`__ | `Next `__ |
+------------------------------+----------------------------+------------------------------------------+
| sig virus | `Home <../index.html>`__ | signal-to-noise ratio |
+------------------------------+----------------------------+------------------------------------------+


Made with leaflet, this map displays which coffee shops on the University of Maryland
campus are open during the Fall and Spring semesters given a selected date and time. When the page initially loads it shows
what coffee shops are currently open (assuming you are in the Eastern Standard time zone.)
I only added locations that are accessible
to everyone, i.e., I did not include the dining halls, which have a prohibitive entry fee
for those not on the meal plan. The time data was
gathered using a web scraper script I wrote in Python. You can check it out
here.
Note: This app works best in Chrome, Firefox, and Edge. If you are using Safari or Internet Explorer, enter
your time in a 24 hour format with a leading zero. Be sure to include the colon as well (e.g. enter
8:30 AM as 08:30, enter 12:15 pm as 12:15).


Reports ternary expressions. Some coding standards prohibit the use of the condition operator, in favor of if statements.
if


Most Extravagent Goat Coin [MEG]
Planned Fork!
Planned Fork! Upgrading is MANDATORY!
Phase 1 – Rebranding and strategy
As many of you will be aware the Megcoin team decided to alter our strategy for Megcoin. The first phase of this strategy was detailed in the re-announcement which saw the coin rebranded and a team formed to advance the coin.
This was successful and as such we succeeded in getting Megcoin listed on Bittrex.
Phase 2 – Block reward and fees
The second phase of our strategy focuses on the specifications of the coin. This will involve improvements to the block reward schedule, total coin supply and the transaction fees.
The planned changes are listed below and will be implemented by a fork at block 18,000:
New block reward schedule:
- 18,000–200,000: 50K Megcoin
- 200,001–400,000: 25K Megcoin
- 400,001–600,000: 12.5K Megcoin
- 600,001–800,000: 6250 Megcoin
- 800,001–1,000,000: 3125 Megcoin
- 1,000,000+: 10 Megcoin
Transaction fee structure:
A typical transaction will now have 1 Megcoin + 0.5% transaction fee to replace the present transaction fee of about 1 Megcoin per transaction. After May 17th, transactions without proper fees will not be accepted by nodes.
Why this benefits Megcoin:
The percentage fee will be used as an incentive to mine and enhance the security of our network, despite decreased reward payouts
The implementation of the percentage fee will also enable the redistribution of wealth accumulated from launch to new users to ensure that the coin is both sustainable and attractive to these new users.
These changes will take effect after block 18,000 and upgrade is MANDATORY
Updated wallets are listed below
About
Megcoin is a revolutionary new cryptocurrency sporting a new algorithm (SCRYPT-N-R) and building upon the strengths of the Bitcoin 0.9 wallet to create a very fast and strong coin. Unlike most other new coins Megcoin is immune to the recent influx of standard Scrypt ASICs and has taken steps to ensure that ASICs will not pose a threat therefore making it an excellent choice for both CPU and GPU miners. Megcoin has a strong development team pushing the advancement of the coin on all fronts and as such is positioned to become a major cryptocurrency. It has not been premined and is fully featured with multiple geographically-diverse DNS seed nodes to ensure extremely fast wallet synchronizations.
Rebrand and Reannouncement
The rebrand and reannouncement of this coin is due to the formation of a strong marketing and development team which was not present at launch. After its formation our team decided that in order to become a key player and strong force in cryptocurrency we needed to create a stronger strategy for success and part of this was rebranding to create a distinct image and plan going forward.
On behalf of the Megcoin team we would like to thank you for your patience with our coin through these changes. We believe that these changes are ultimately for the best and are essential if we are to push this coin to the next level. We urge you to not miss out on this opportunity to be a part of our coins journey.
Note: All previously mined coins remain unchanged as the changes are related only to branding and strategy.
Most Extravagant Goat?
Meet Meg, our coin mascot. A friendly extravagant goat who is the face of our coin and movement. Meg bought all of his gold bling with his Megcoin wealth but still remains excited for what's coming next. Join Meg!
Specifications:
- Launched May 3rd, 2014
- PoW Algo: Scrypt-8-4 (scrypt-n-r)
- Premine: 0%
- Total: Infinite (20K final block reward)
- Block time: 60 seconds
- Reward halved: Every 200,000 blocks
- Rewards mature: 120 blocks (~2 hours)
- Difficulty adjustment: Every block (Digishield)
- Wallet forked from Bitcoin 0.9
What is Scrypt-N-R and how does it make Megcoin superior?
Megcoin's algorithm uses a new algorithm dubbed scrypt-N-R. Typically, scrypt
means scrypt with N=1024, R=1, P=1. This algorithm changes R for more granular tuning of memory usage. Currently, there is only the wallet miner and cpuminer(minerd) ported to the new algorithm. The memory usage of scrypt-8-4 is only 4Kbytes, compared to normal scrypt where it is 128Kbytes.
Scrypt-R-N ASICs are not practical to make for Megcoin because of the short "payout streak" period of around 1.5 years. If ASICs were produced for the new algorithm it would be near the end of the large block rewards when mining is needed more for network stability rather than for coin generation.
Security provided by Digishield
Megcoin uses the Digishield difficulty algorithm which has been proven stable and effective on Dogecoin and Digibyte. Although multipools shouldn't pose a threat due to our unique algorithm parameters, Digishield has been proven to handle large hashrate changes very well to ensure that the network is never stuck with slow blocks or vulnerable to a timewarp attack.
Advanced wallet building upon Bitcoin 0.9
Unlike many other new Scrypt altcoins Megcoin has decided to base our wallet on Bitcoin 0.9 which we forked to produce Megcoin's wallet. This decision was taken to ensure that the Megcoin wallet included many of the advancements that Bitcoin 0.9 has along with some of our own:
- A faster graphical user interface (supporting Qt5 as well).
- Fixes for transaction malleability.
- Services separated into megcoind, megcoin-cli and megcoin-qt.
- Many more features which can be seen in the bitcoin 0.9 changelog.
Wallet download
- Windows Wallet (32bit)
- Mac OSX wallet coming soon.
- Linux wallet coming soon.
The source code is available on github for self-compilation and review.
Mining
Mining Megcoin couldn't be easier, get started with out CPU miner below:
- CPUminer - Windows build (x64)
- The wallet supports solo mining using
setgenerate true -1
See also an easy getting started guide here.
Pools
Megcoin is currently supported by these trusted pools, more will follow:
Reward schedule:
- 1–200,000: 500K Megcoin
- 200,001–400,000: 250K Megcoin
- 400,001–600,000: 125K Megcoin
- 600,001–800,000: 62500 Megcoin
- 800,001–1,000,000: 31,250 Megcoin
- 1,000,000+: 20,000 Megcoin
Community and Resources
Come and get involved in our Megcoin communities, we look forward to hearing from you:
Exchanges
- Bittrex
- We are working to get Megcoin onto Mintpal and Cryptsy along with as many other exchanges as possible, this is a key and urgent priority of our team.
Block explorers
Merchandise
Services
We understand that gaining widespread adoption and success for our coin will rely strongly on the production of new services which utilise Megcoin. At present we have an IRC tipbot for Megcoin (megtip) which you can use in your channel upon request. We will be pushing strongly for more services in the future and welcome any developer who would like to use Megcoin to get in contact with our devteam.
Testnet
If you would like to test services or mining with Megcoin we have testnet nodes running meaning that syncing should be effortless. If you would like more details then please contact our team.
Nodes
There are multiple geographically-diverse DNS seeds built into the wallet ensuring that the wallet will sync very quickly. If you have a reliable node and would like to help strenghten the Megcoin network then please contact us and we will add it to the node list. Please note that no addnode arguments should be required right now.
Bounties
- AMD GPU Miner - 130 Million MEG (Bounty address: MSGoyrBfXad1Pv8Jqc3t74a2yBsDoDbE1G)
- Nvidia GPU Miner - 4 Million MEG
- Informative youtube video suitable of the homepage - 25 Million MEG
- Better website design - 25 Million MEG -IN PROGRESS
- Established merchant to accept Megcoin - 50 Million MEG
- Service using Megcoin, such as faucet, dice game, etc - 1 Million MEG (rewarded up to 10 times)
- Mac OSX Wallet - 20 Million MEG -IN PROGRESS
- Ubuntu wallet package - 20 Million MEG
Credits
Please consider supporting the artist of our logo by donating Dogecoin here: DC1ZEaQMuQfgcYvtd6DhJ6k4Y8ogk9VKYy


{% extends "shelves/shelf_base.html" %} {% block meta_title %}Omnomer - Delete Shelf{% endblock %} {% block shelf_main %}
Are you sure you want to delete the shelf {{ shelf }}?


When giant pandas are born, they are tiny, blind, and pink, with few hairs.
About 300 giant pandas live in captivity; no more than 3,000 exist in the wild. The endangered species is not uncommon in pop culture, though, evidenced by animated films such as DreamWorks’ Kung Fu Panda, news stories every time a cub is born in a zoo, and stuffed animals on beds the world over. Vegetarian bears with black-rimmed eyes and fluffy coats, giant pandas are as peculiar as they are rare.