public interface AuthorizationConstraint
| Modifier and Type | Method and Description |
|---|---|
boolean |
authorized(Principal principal)
Determines if a
Principal is authorized to access this privilege. |
AuthenticationChallenge[] |
challenges()
Returns the authentication
AuthenticationChallenge s that are bound
to this constraint. |
boolean |
equals(AuthorizationConstraint constraint)
All
AuthorizationConstraint implementations MUST implement the
equals(AuthorizationConstraint) method correctly. |
boolean |
equals(Object obj)
All
AuthorizationConstraint implementations MUST implement the
Object.equals(Object) method correctly. |
int |
hashCode()
All
AuthorizationConstraint implementations MUST implement the
Object.hashCode() method correctly. |
String |
name()
The unique name assigned to this constraint.
|
String name()
AuthorizationConstraint
to share the same name.AuthenticationChallenge[] challenges()
AuthenticationChallenge
s that are bound
to this constraint.AuthenticationChallenge
instances that the
constraint is bound toboolean authorized(Principal principal)
Principal
is authorized to access this privilege.principal
- boolean equals(Object obj)
AuthorizationConstraint
implementations MUST implement the
Object.equals(Object)
method correctly.
Typical implementations of this method should check if the specified object
is an instance of AuthorizationConstraint
. If it is then delegate
to equals(AuthorizationConstraint)
. If not then return false.equals
in class Object
obj
- The object to test for equality.equals(AuthorizationConstraint)
boolean equals(AuthorizationConstraint constraint)
AuthorizationConstraint
implementations MUST implement the
equals(AuthorizationConstraint)
method correctly.
Typical implementations of this method should check if the specified object
is an instance of the same sub-type of AuthorizationConstraint
. If
it is then compare each of the properties of the sub-type for equality. If
it is not of the same sub-type then return false.constraint
- The AuthorizationConstraint
to test for equalityint hashCode()
AuthorizationConstraint
implementations MUST implement the
Object.hashCode()
method correctly.hashCode
in class Object
Object.hashCode()
Oracle REST Data Services Plugin API version: <IP_ADDRESS>.18.05 Copyright © 2015 Oracle Corp. All Rights Reserved.


What is thouest name?
What password do you use the most?
WHat is a secret that you never told your parents? Spill the beans
What is your favorite musical artist? Tom Petty Tom Petty Guns N Roses
Please check off the most talkative student in Web Design: Carlee Carlee Carlee
What state do you live?


--- title: Wheel Speed Sensors subtitle: Caltech Racing Team layout: default modal-id: 2 date: 2020-10-08 thumbnail: tachometer_top.png project-date: June 2020 - present category: PCB Design ---
This Wheel Speed Sensors board is implemented onto the electric car designed by the Caltech Racing Team. It essentially serves as the tachometer, measuring how fast the car's wheels are rotating. The implementation will be done with an analog output hall effect sensor as well as two symetrically placed neodymium magnets. The signals received are processed as interrupts into the STM32F469 Microntroller to provide information about the car's RPM. The next steps involve board fabrication as well as troubleshooting.


Default Controls
Servoing
Traj. Playback
Ellipsoidal Control
Body Registration
TTS
Tasks
RYDS
Control Head
Control Left Hand
Control Right Hand
Control Base
Movement Frame:
Auto
Torso
Hand
1. Activity
2. Arm
Right
Left
3. Trajectory
Play
Pause
Stop
Move to Setup
Execute Traj.
Setup AND Execute
Shaving
Ellipsoid Controller
Adjust Mirror
Start/Stop Razor
Move to Selection
Stop
Translate
Rotate
Reset
Left Gripper
Left Close
Left Open
Right Gripper
Right Close
Right Open
Torso
Down
Up


Registration Form
PHOTO:-
NAME:-
FATHER NAME:-
GENDER:-
male
female
DOB:-
Mob.NO:-
EMAIL-ID:-
PASWORD:-
LANGUAGE KNOWN:-
hindi
english
spanish
COUNTRY:-
India
Usa
Africa
Asterila
UPLOAD RESUME:-
FEEDBACK:-


--- layout: app/template/default title: Get In Touch ---
If you are interested please get in contact, I look forward to hearing from you.


@*
* Copyright 2019 HM Revenue & Customs
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*@
@import play.twirl.api.Html
@import uk.gov.hmrc.play.views.html._
@import models.auth.AuthenticatedUserRequest
@(changeRelationshipForm: Form[ChangeRelationship])(implicit messages: Messages,
request: AuthenticatedUserRequest[_],
templateRenderer: uk.gov.hmrc.renderer.TemplateRenderer,
formPartialRetriever: uk.gov.hmrc.play.partials.FormPartialRetriever)
@templates.tamc_main(
title = Messages("title.pattern", Messages("title.make-a-change")),
mainConfig = views.helpers.MainConfig()) {
@templates.form_error_notification(changeRelationshipForm, formErrorMessage = "pages.form.error.mandatory.data")


Appearance
Unlike its pre-evolutions, Dragonite has limbs. In all its appearance, it resembles dragons from the myths of the Middle Ages. Despite the fact that it decreases after evolution, Dragonite is still larger than a person. With small wings and a large body, Dragonite can fly faster than the speed of sound.


Coin Heavens, also called the Cloud Bonus or Bonus Stage, are bonus areas found in most Super Mario games.
In all games it is included in, Coin Heaven is secretly located in the sky in several levels, accessed through a hidden item or secret path. It is loaded with coins, whi...


The management console could not be loaded.
Make sure the server is up and running. Please check the log files for possible errors during startup.
Verify you have added users which are able to access the admin console.
To add a new user execute the
add-user.sh
script within the bin folder of your installation and enter the requested information.
Check that the management endpoint at ${endpoints().dmr()} is available.
Make sure you've added ${org.jboss.hal.config.Endpoints.getBaseUrl()} as allowed origin and reload the server. Use one of of the following CLI commands to add allowed origins:
Standalone:
/core-service=management/management-interface=http-interface:list-add(name=allowed-origins,value=${org.jboss.hal.config.Endpoints.getBaseUrl()})
Domain:
/host=master/core-service=management/management-interface=http-interface:list-add(name=allowed-origins,value=${org.jboss.hal.config.Endpoints.getBaseUrl()})


Administrators can log in the website to manage employees and make employee attendance reports
You do not have to buy time attendance machines at high prices, instead of that, you can deploy the system easily just with a beacon
Employees will not be expected to queue up for check in, they can use the app to check in and check out immediately


Implemented a ray tracing system to simulate the optics of pinhole camera by using the core concepts behind synthesis of a perspective 3D image
Used shading models that approximate ambient, diffuse, and specular light reflection on surface, which give objects the appearance of having different materials
Utilized the algorithms to allow at least 10 reflections for each ray
Developed a virtual orrery that animates and renders the relative motions of the planets in the solar system against a starry backdrop
Used OpenGL shader code to implement geometry specification, coordinate systems, reference frames, interactive input, hierarchical scene organization, model and view transforms, texture mapping, shading, and real-time animation


dtplite - Lightweight DocTools Markup Processor
The application described by this document, dtplite, is the successor to the extremely simple mpexpand. Influenced in its functionality by the dtp doctools processor it is much more powerful than mpexpand, yet still as easy to use; definitely easier than dtp with its myriad of subcommands and options.
dtplite is based upon the package doctools, like the other two processors.
dtplite was written with the following three use cases in mind.
Validation of a single document, i.e. checking that it was written in valid doctools format. This mode can also be used to get a preliminary version of the formatted output for a single document, for display in a browser, nroff, etc., allowing proofreading of the formatting.
Generation of the formatted documentation for a single package, i.e. all the manpages, plus a table of contents and an index of keywords.
An extension of the previous mode of operation, a method for the easy generation of one documentation tree for several packages, and especially of a unified table of contents and keyword index.
Beyond the above we also want to make use of the customization features provided by the HTML formatter. It is not the only format the application should be able to generate, but we anticipiate it to be the most commonly used, and it is one of the few which do provide customization hooks.
We allow the caller to specify a header string, footer string, a stylesheet, and data for a bar of navigation links at the top of the generated document. While all can be set as long as the formatting engine provides an appropriate engine parameter (See section OPTIONS) the last two have internal processing which make them specific to HTML.
This is the form for use case [1]. The options will be explained later, in section OPTIONS.
This argument specifies where to write the generated document. It can be the path to a file or directory, or -. The last value causes the application to write the generated documented to stdout.
If the output does not exist then [file dirname $output] has to exist and must be a writable directory. The generated document will be written to a file in that directory, and the name of that file will be derived from the inputfile, the format, and the value given to option -ext (if present).
This argument specifies the formatting engine to use when processing the input, and thus the format of the generated document. See section FORMATS for the possibilities recognized by the application.
This argument specifies the path to the file to process. It has to exist, must be readable, and written in doctools format.
This is a simpler form for use case [1]. The "validate" format generates no output at all, only syntax checks are performed. As such the specification of an output file or other options is not necessary and left out.
This is the form for use case [2]. It differs from the form for use case [1] by having the input documents specified through a directory instead of a file. The other arguments are identical, except for output, which now has to be the path to an existing and writable directory.
The input documents are all files in inputdirectory or any of its subdirectories which were recognized by fileutil::fileType as containing text in doctools format.
This is the form for use case [3]. The only difference to the form for use case [2] is the additional option -merge.
Each such call will merge the generated documents coming from processing the input documents under inputdirectory or any of its subdirectories to the files under output. In this manner it is possible to incrementally build the unified documentation for any number of packages. Note that it is necessary to run through all the packages twice to get fully correct cross-references (for formats supporting them).
This section describes all the options available to the user of the application, with the exception of the options -o and -merge. These two were described already, in section COMMAND LINE.
At first the format argument will be treated as a path to a tcl file containing the code for the requested formatting engine. The argument will be treated as the name of one of the predefined formats listed below if and only if the path does not exist.
Note a limitation: If treating the format as path to the tcl script implementing the engine was sucessful, then this script has to implement not only the engine API for doctools, i.e. doctools_api, but for doctoc_api and docidx_api as well. Otherwise the generation of a table of contents and of a keyword index will fail.
List of predefined formats, i.e. as provided by the package doctools:
The processor generates *roff output, the standard format for unix manpages.
The processor generates HTML output, for usage in and display by web browsers. This engine is currently the only one providing the various engine parameters required for the additional customaization of the output.
The processor generates TMML output, the Tcl Manpage Markup Language, a derivative of XML.
The processor generates LaTeX output.
The processor generates Wiki markup as understood by wikit.
The processor extracts the information provided by manpage_begin. This format is used internally to extract the meta data from which both table of contents and keyword index are derived from.
The processor does not generate any output. This is equivalent to validate.
In this section we describe the directory structures generated by the application under output when processing all documents in an inputdirectory. In other words, this is only relevant to the use cases [2] and [3].
The following directory structure is created when processing a single set of input documents. The file extension used is for output in HTML, but that is not relevant to the structure and was just used to have proper file names.
output/ toc.html index.html files/ path/to/FOO.html
The last line in the example shows the document generated for a file FOO located at
inputdirectory/path/to/FOO
When merging many packages into a unified set of documents the generated directory structure is a bit deeper:
output .toc .idx .tocdoc .idxdoc .xrf toc.html index.html FOO1/ ... FOO2/ toc.html files/ path/to/BAR.html
Each of the directories FOO1, ... contains the documents generated for the package FOO1, ... and follows the structure shown for use case [2]. The only exception is that there is no per-package index.
The files ".toc", ".idx", and ".xrf" contain the internal status of the whole output and will be read and updated by the next invokation. Their contents will not be documented. Remove these files when all packages wanted for the output have been processed, i.e. when the output is complete.
The files ".tocdoc", and ".idxdoc", are intermediate files in doctoc and docidx markup, respectively, containing the main table of contents and keyword index for the set of documents before their conversion to the chosen output format. They are left in place, i.e. not deleted, to serve as demonstrations of doctoc and docidx markup.
This document, and the package it describes, will undoubtedly contain bugs and other problems. Please report such in the category doctools of the Tcllib Trackers. Please also report any ideas for enhancements you may have for either package and/or documentation.
When proposing code changes, please provide unified diffs, i.e the output of diff -u.
Note further that attachments are strongly preferred over inlined patches. Attachments can be made by going to the Edit form of the ticket immediately after its creation, and then using the left-most button in the secondary navigation bar.
Documentation tools
Copyright © 2004-2013 Andreas Kupries <andreas_kupries@users.sourceforge.net>


Disney - Disney Color By Behr
Colorcharts.org certification: *** Fandecks scanned on a X-Rite CFS-57 Spectrophotometer


Buhari greets ex-President Jonathan at 62
by The Eagle OnlinePresident Muhammadu Buhari has felicitated with former President Goodluck Jonathan on his 62nd birthday.
Buhari, in a statement by his spokesman, Femi Adesina, in Abuja on Wednesday, joined the nation in praying for good health and strength for Jonathan to keep serving the nation.
The President rejoiced with family, friends and political associates of the former president, lauding him for good counsels to leaders within and outside Nigeria since he left office, sharing his experience of serving at different levels of governance.
According to him, the former President’s legacy of humility and patriotism will continue to resonate, inspiring generations to come on the sacrifices made for the stability of democracy and promotion of sustainable development.
The President wished the former President and his family more years of joyful celebrations.


the and for {background that with are margin {border-style immune px;} #ffffff;} this The health []. factors COVID- This such and, not other px; should {font-family font-size from have lifestyles metabolic must nutrition will can double; energy environmental nutritional one research risk system which Elsevier age border-color border-width consequences during effects human its particularly precision reduction solid; therefore, these through {font-style {font-weight These available been bold centre changes courier; em; future has infections last lead main more processes pt;} public resource response severe social some their viral vitamin


Getting Started¶
Option A: For the non-coder¶
If you don’t want to do any coding yourself and instead just want to view and execute the code we’ve already written using our Jupyter Notebooks, use this link: and a computing environment will be set up for you in the cloud (for free). This setup process can take several minutes, so be patient. Once that setup is done, you should be able to navigate to the “notebooks” folder of the repository and open and execute the Jupyter Notebooks without having to install anything on your own machine.
Option B: For the coder¶
This Git repo utilizes the Git Large File Storage (LFS) system. Git LFS is used here to replace large files files (identified in .gitattributes
) such as shapefiles, point clouds, and rasters with text pointers inside Git, while still storing files not excluded by .gitignore
on GitHub. Very large geospatial data files such as point clouds (.las, .las) and rasters (.asc, .tif) are currently set up to be ignored by Git entirely because they can easily exceed GitHub storage allowances. Third party solutions for storing and sharing large datasets are used to work around this.
Use the conda package manager to reproduce the computing environment we used in developing this repo. Get Anaconda or Miniconda to do so.
- Install Git LFS
- Clone this repo onto your local machine:
git clone https://github.com/d-diaz/Lidar_Plot_Registration.git
- Create a conda environment from the environment.yml file included in this repo:
conda env create --name forest3d --file environment.yml
- Activate this new conda environment:
source activate forest3d
(Linux, OSX) oractivate forest3d
(Windows) - Start a Jupyter session:
jupyter notebook
- In your web browser Jupyter session, navigate to the “notebooks” folder in this repo and open up one of the Jupyter Notebooks!


HACKED BY [ X47 ]
Idiots dont deserve place in cyberworld.

Greatz To : No|Mercy47 - Exodus! - Cybersex01 - MozillaFirefuck - !MAG!NARYx - Alternation! - Codep4rty - |Redictum| - Extract47 - Lastworld?
[ Wanna fix this? just look at the metadata ]


Introduced in Excel 11 (2003) the DROPDOWNOBJIDS record stores the drop down drawing object ids used for the AutoFilter etc. in a workbook. These ids are persisted so the next time the book is loaded, these ids can be re-used.
This record is created to help ease the issue of limited drawing object ids so the limit would not be reached so easily with a huge Table or a Table with many columns.
In Excel 2003, at the end of the AutoFilter drop down object ids, if there is a total row used on any Table(s), its drop down object id is also saved as the last item of the array of drop down object ids.
Record Data
|
Offset |
Field Name |
Size |
Contents |
|
4 |
rt |
2 |
Record type; this matches the BIFF rt in the first two bytes of the record; =0874h |
|
6 |
grbitFrt |
2 |
FRT cell
reference flag |
|
8 |
(Reserved) |
8 |
Currently not used, set to 0. |
|
16 |
cidObj |
2 |
Count of Object ids |
|
18 |
rgidObj |
var |
Array of cidObj many object ids, 2 bytes each |


Arrays and Hashes
Use them appropriately and you won’t regret!
March 14, 2015
So, this is the end of our third week of Phase 0 in DBC. By now, we’re being introduced to Ruby world by working the basic variable types and operations. At this point, some variable types may seem very similar, and we may ask ourselves: “but why the hell did they create those two?”. A common example of types that cause this kind of reaction is when we consider Arrays and Hashes. Both arrays and hashes are variable types that store collections of objects. Also, in both cases, we access objects by keys. Still, there are several aspects that differentiate these two variable types.
When it comes to Arrays, keys don’t have to be defined on code, and they are always integers, starting on 0. Because of this characteristic, arrays are commonly defined as ordered lists. This means that, every time you need to store a collection of ordered data, you should use an array. A simple example would be, for example, to have an array that stores the days of the week:
weekdays = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday]
Whenever you want to refer to any of the weekdays, you can use their keys, i.e., their position in the array (remembering that our first spot is always position 0).
>> weekdays[2]
=>”Tuesday”
When we talk about Hashes, keys are defined on code and may be any object you want to. This means that hashes are, by default, unordered lists (of course you can order them, using code, if you need to). They are very useful when you need to reference values to information that can make you easily access them. In my researches, I’ve seen a pretty didactic example of hash usage. Imagine you create a hash to store hexadecimal values of colors:
hexacolors = { ‘Red' => #FF0000 , ‘Blue’ => #0000FF , ‘Black' => #000000 , ‘White’ => #FFFFFF}
If you want to refer to hexadecimal of any of the colors in your hash, you can simply do that:
>> hexacolors[‘Black']
=> #000000
There are other particular aspects about hashes: because of Ruby construction on these variable types, hashes are way faster for lookups compared to arrays. Also, it is possible to return a default value when you search for a value of a key that doesn’t exist.
That said, next time you’re not 100% confident about using arrays or hashes, ask yourself:
- Is it important to have the content ordered?
- Will it be easier to access information if I can relate it to a custom key?
- Will I have to lookup on these information?


Domain-oriented Shopping Cart Example with tarant-vue
Behaviour
- Getting the shop information is delayed for 500ms
- Adding an item to a cart is delayed for 250ms
- When an item is added to the shopping cart, the vue component is delayed for 1s, so the product list will update quicker
Fun fact: Try to add more than the limit of items, you'll see that it's not possible (even if actors are really slow),
because actors are transactional and receive messages one by one.


GESIS Notebooks Overview
This service is intended for use by social scientists. You can build and launch all binder-ready projects without logging in. If you want to have more persistent projects, you need to log in.
The service is free for social scientists. In the future GESIS may include a premium offer with additional features.
You can select any language/environment available from our gallery of more than 5000 binder-ready projects. The gallery contains projects from the MyBinder.org Events Archive.
For the anonymous use of via Binder, the service has a limit of:
- 4 GB memory
- 2 CPU cores
- 10 minutes inactivity timeout
- 32 GB memory
- 2 CPU cores
- 40 minutes inactivity timeout
- a maximum of 10 GB of persistent disk space
For questions regarding Jupyter or the Binder import, join the discussion, read the docs or see the code. Please open an issue on our GitHub repository for questions regarding GESIS Notebooks. We are looking forward to hearing from you.
If possible, please include:
- a short description
- steps necessary to reproduce the problem
- a screenshot of the issue
The project is open-source and the code is available at https://github.com/gesiscss/orc.
You can use token request page to create a JupyterHub API token. You can also read more about the JupyterHub API in the JupyterHub docs, how to make an API request and the different ways you can use the API.
- Launch gh/gesiscss/data_science_image and start a terminal
- Run zip -r ~/myprojects.zip /projects/* in the terminal
- Go to the Notebook dashboard, select myprojects.zip file and download
Binder Project Import
Binder is an open-source project that enables the creation of shareable, interactive, reproducible scientific analysis environments. You can read more about Binder here.
After launching a new repository, it will appear in Your Projects:
- Concurrently store up to 5 projects
- Control the projects you are currently working on
- Directly link to the project repositories
The Binder Federation maintains a machine readable archive of projects that are binder-ready and suited for the import in GESIS Notebooks. A gallery for you to browse is available at https://notebooks.gesis.org/gallery/.
For more information about making a Notebook binder-ready, take a look at the binder user guide.
Just like mybinder.org, you can create a direct launch link for a notebook repository. To launch the notebook without persistence (no login required) you can create a URL like https://notebooks.gesis.org/binder/v2/gh/github_account_name/repository_name/HEAD with appropriate 'github_account_name' and 'repository_name'. To launch this with persistence (login required) you can construct a URL with https://notebooks.gesis.org/services/binder/v2/gh/github_account_name/repository_name/HEAD.


With my internship at CAIDA, I was assigned the task to create a new logo for their new project: P.A.N.D.A. This is still currently in process so this is the process I have made so far.
This is a individual task I created all designs and uploaded for feedback.
For the PANDA logo, this task was a redesign. The current logo is the above image.
I went on the project profiles and read about the project and what it is used for. Its a platform that acts as a hub for resources and tools and a user can combine individual resources and tools. I went into sketching. I sketched various different ways to resemble data, platforms, and pieces coming together.
I sent this to my supervisor and I got feedback to add panda graphics as suggestions.
These were sent to the rest of the programmers and principal investigators and I got more feedback.
Some suggested to put more emphasis on the idea of data and pieces coming together and a bonus would be to have a panda as a hidden image. I started looking at inspiration from pipes, roads and puzzle pieces. I sketched realistic pieces of pipes, roads and puzzles and then abstracts of them. I looked towards emphasizing the data functions more than the art and panda idea. I also created ideas that have the escher style.
My supervisor and I decided to stick with the cube idea but also try to play with the word 'PANDA' so I went back to the whiteboard
It was ready to be sent to the other programmers and principal investigator and they all preferred B2, horray! Progress! I went back to the whiteboard to do various colors. Some suggested to have a panda in the cube design as well so I made those variations as well.
There was a lean towards warmer color schemes and to have the panda dipping into a pool of data
One of the phases of design is going back. After posting these designs, we realized that the cube idea for the logo doesn't emphasize data enough. So I went on a call with other principle investiagators and go more feedback, asked questions about ideas and what words they imagined and resources they had. I ended the call and went to work with 9 radical designs.
This is where I left off and while this is a continuing project I put this in my portfolio to show my design process and how I work with illustrator.
In the near future, I will be looking at ideas to use more pipe-like images and more emphasis on puzzles.


Paste Random Row
Input Row
has suggestions
track title:
War Song
remix title:
Peace Remix
main artist:
John Smith
featured artist:
Joanna Smith
featured artist:
Ioanna Smith
use selected
skip
Titles
Track Title
Version / Remix Title
Competitors
Main Artist
Featured Artist(s)
add row
Show More
Show Less
Author
Composer
Reset


{% extends 'base.html' %} {% block page_title %} Do Life Yourself - Member's Home Page {% endblock %} {% block content %}
Log in, or sign up for free today.


Watch: Swara Bhasker abuses a four-year-old for calling her 'aunty'
by Entertainment DeskBollywood actor Swara Bhasker is facing severe backlash on social media for abusing a four-year-old child actor as she recalled an incident on the chat show Son Of Abish.
A video spreading like wildfire on social media shows Swara using the swear words for a child actor with whom she worked with in an advertisement shoot during her early days in the film industry.
Apparently, Swara got angry because the child had addressed her as aunty.
In the video clip, the Veere Di Wedding actor is seen speaking about how disappointed she was with the shoot, adding that the kid calling her “aunty” only made her angrier.
According to Swara, children were basically “evil” and this kid was only a brat, throwing tantrums.
Twitterati started slamming the actor as soon as the video went viral, and the hashtag #SwaraAunty has been trending on the micro-blogging website since Tuesday morning.
According to IBTimes, an NGO – Legal Rights Protection Forum – has reportedly filed a complaint to National Commission for Protection of Child Rights, and demanded action against Swara.


|
Assimp
5.0.1, master @ cd42b955
|
Contains input data for GenerateOutputMeshes_3DGS_MDL7. More...
Public Member Functions | |
| IntSplitGroupData_MDL7 (IntSharedData_MDL7 &_shared, std::vector< aiMesh * > &_avOutList) | |
| Construction from a given shared data set. More... | |
| ~IntSplitGroupData_MDL7 () | |
| Destruction: properly delete all allocated resources. More... | |
Public Attributes | |
| std::vector< unsigned int > ** | aiSplit |
| Contains a list of all faces per material. More... | |
| std::vector< aiMesh * > & | avOutList |
| List of meshes. More... | |
| IntSharedData_MDL7 & | shared |
| Shared data for all groups of the model. More... | |
Contains input data for GenerateOutputMeshes_3DGS_MDL7.
|
inline |
Construction from a given shared data set.
|
inline |
Destruction: properly delete all allocated resources.
| std::vector<unsigned int>** Assimp::MDL::IntSplitGroupData_MDL7::aiSplit |
Contains a list of all faces per material.
| std::vector<aiMesh*>& Assimp::MDL::IntSplitGroupData_MDL7::avOutList |
List of meshes.
| IntSharedData_MDL7& Assimp::MDL::IntSplitGroupData_MDL7::shared |
Shared data for all groups of the model.


Railroad Worker Abey:
Please, check out what is making all the noises around here at night.
I'm sure you'll make it possible for me to sleep like a baby tonight!


Home
Tour Dates
Purchase Now
Purchase Now
Menu
Purchase Order
Purchase Order
Please enter a valid email address
Name
Email
Merchandise
CD
Poster
Hat
T-Shirt
Request Options
Autographed
Engraved
Original
Did you want that wrapped? (gift options)
Yes
No


Settings
Looking For
Growth
(Fast Growing)
Value
(Reasonable Valuations)
Fixed Income
(Higher Dividend)
Show Advanced Options
(Full control)
Advanced Options:
Income (YoY Growth):
Income (QoQ Growth):
Income (Yearly Growth):
Profits (YoY Growth):
Profits (QoQ Growth):
Profits (Yearly Growth):
EPS (YoY Growth):
EPS (QoQ Growth):
EPS (Yearly Growth):
Margins Percent:
Margins (Yearly Growth):
PE:
Dividend Yield:
Dividend Growth:
Book Value Growth:
Changes reflect only in Personal tab
Green/Blue Band
Green Band (Lower End):
(/green or /all)
Blue Band (Lower End):
(/blue or /all)
PE (Lower End):
PE (Higher End):
(/pee)
PEG (Lower End):
PEG (Higher End):
(/peg)
Dividend Yield (Lower End):
Dividend Yield (Higher End):
(/divyld)
Changes reflect in Optimized and Personal tabs.
When values for PEG and Dividend Yield are 0, we enter "auto mode". In auto mode, companies with PEG less than Dividend Yield are automatically selected!
Tolerance
Score Consistency:
Select Consistency
Only Consistent Ones
Fluctuations Okay
Okay With Inconsistency
(/scrcon)
Top-line:
Select Consistency
Only Consistent Ones
Fluctuations Okay
Okay With Inconsistency
(/consistent)
Bottom-line:
Select Consistency
Only Consistent Ones
Fluctuations Okay
Okay With Inconsistency
(/consistent)
Price Above 30 DMA (%):
(/price)
Max Interest Paid (%):
(/interest)
Min Profit Margin (%):
(/margin)
Min YoY Qtrly TL Growth (%):
(/tlgrowth)
BL in sync with TL (%):
(/sync Tip: Use with /tlgrowth)
Min ROA for (%):
(/retonass)
Changes reflect in Optimized and Personal tabs
Email
Email watchlist stocks trading below 30 DMA
(2 mails / day. 10:15 am and 3:15 am)
Newsletter
(Max 2 mails / month)
Sign In required
Tooltips
Enable/Disable help tooltips
Account
Membership:
Reset/Delete
This will just reset your browser's localStorage data. Data on the server will not be affected.
Delete Account Page


Our Story
Jim and Andrea Labelle began Mexpro in their basement in 1999. Jim was essentially born into the insurance industry, as his father owned a prominent business in Scottsdale, Arizona. He had a strong understanding of the need for being insured with a quality [A-rated] insurance company when an accident occurs.
Andrea, always on the cutting edge of things, knew the internet was taking off and understood exactly what kind of quality product Jim was conceptualizing. She knew an online product was what they needed to do.
Jim's experience and Andrea's drive got them appointments with Mexico's top insurance companies. Before long, those companies were serving Mexpro's customers (now over 1 million) with bilingual policies, claims personnel and adjusters. All with the best quality coverage and the ease of purchasing online.
Our Partner Insurers
We chose to work with several insurance companies so we could allow you to choose the best coverage at a price you would be comfortable with. Our insurers provide the most competitive choices in coverage, pricing, and most importantly, financial stability. All our insurers are A-rated by A.M. Best and have a strong history of paying claims.
Our People
We have a wealth of experience in the insurance business, beginning with our founders, who started Mexpro with 20 years in the industry. Mexpro's agents have numerous professional designations including CIC (Certified Insurance Counselor), CISR (Certified Insurance Service Representative). And, some of us are former employees of the world's largest insurance companies and brokerages.
Most of our staff of 25 employees have been employed with us for 10 years or more. We pride ourselves in a team who provides the highest level of service and are experts in Mexico auto insurance because at Mexpro, THE CUSTOMER ALWAYS COMES FIRST.
Our Technology
Mexpro's patented quoting system was created in-house via a brilliant staff of programmers. All our IT people stay on the cutting edge in their area of expertise to be sure we meet all your needs. Whether it be finding what you need on our website or quickly getting a quote and policy, we are here to serve you.
Your Personal Information is Safe
Our website and quote forms are SSL (Secure Socket Layer) encrypted and we never keep your credit card information. Our systems are secure so you don’t have to worry about buying online with Mexpro.
An NFP Company
Mexpro was recently purchased by NFP, one of the Nation's leading insurance brokerages and consulting companies. Their dedication to customers and employees, as well as their mission of being honest and authentic, follows our business model and is a perfect fit.
Don't Believe Us?
Read these testimonials from our happy customers...
-
ABSOLUTELY LOVE the ease of getting my trip insurance on your site. I am a regular customer and thanks for the convenience.
Chet Chetkauskas
Surprise, Arizona -
We purchased insurance from you for a recent Mexico trip, including Mex-Visit travel assist. When our car broke down I called the 800 number and a tow truck was called for us, which came in about an hour. The driver took us to a great mechanic who fixed the problem immediately, at a very reasonable price. Less than four hours after breaking down, we were back on the road and continued safely to our destination. I don't know what we would have done without your assistance. Thank-you. The insurance representative was very helpful &reassuring at a time when I was nervous about being stranded.
Betsy
-
GREAT SERVICE, FAST AND AT A GOOD PRICE. THANK YOU!
Mircea Buzila
Youngtown, Arizona


Select building
Upload images
Hide all overlays
Show all overlays
Hide all markers
Show all markers
Delete all
Save overlay
Drag & Drop Images Here
-or-
Click to open the file Browser


--- layout: landing_page title: Which banks support Two Factor Authentication? description: Listing of which large US banks support Two Factor Authentication, and which forms of 2FA they support. us_banks: - Chase - Bank of America - Citibank - Wells Fargo - Marcus by Goldman Sachs - TD Bank - PNC Bank - Capital One - HSBC - BMO Harris Bank - Fifth Third Bank - Ally Bank - Barclays US - USAA - Citizens Bank - First Republic Bank ---
| Bank Name | Docs | SMS | Phone Call | Hardware token | Software token | |||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
{% if website.landing_page_url %}
{{ website.name }}
{% else %}
{{ website.name }}
{% endif %}
|
{% if website.tfa %}
{% assign tfa = website.tfa %}
{% if website.doc %} {% endif %} | {% if tfa contains "sms" %} {% endif %} | {% if tfa contains "phone" %} {%endif%} | {% if tfa contains "email" %} {% endif %} |
{% if tfa contains "hardware" %}
{% endif %}
{% if tfa contains "u2f" %}
{% endif %}
|
{% if tfa contains "totp" %}
{% endif %}
{% if tfa contains "proprietary" %}
{% endif %}
|
{% else %}
No Two Factor Authentication Support | {% endif %}


TSA stands for the “Technology Student Association.” The motto is “Learning to lead in a technical world.” Our chapter definitely lives by this motto every single day. TSA has chapters all over the United States with a common interest in technology. STEM is a field that is in critical need of workers and TSA assists in supplying these workers.
TSA is a well-known and esteemed club at Chamblee Charter High School. At our chapter, students get their events based on their selections as well as selections made by our teachers. This helps to ensure that everyone is doing something that they love. At Chamblee, TSA has constant meetings and check-ins to ensure that we are always on track to have finished projects by the State Leadership Conference.


The following email is written by Brian Harry and published by Brad Abrams (brada), written in 2000. It’s about the .NET runtime (C#, F#, VB), and why they decided to go with Garbage collection instead of sticking with reference counting. Worth a read if you’re interested in the debate between GC systems vs Ref Counted systems.
The question is all the more relevant these days (2020), with Ref Counted systems in vogue and GC out of fashion. Languages like Rust and Swift are popularizing the idea of a ref-counted only language, and languages like D and Nim are trying to introduce borrowing and pure ref-counting into their languages.
I’ve extracted it from the Microsoft blogs and re-rendered it to be easier to read. There are no differences in content, save for formatting changes.
The source can be found here: Link
Thomas’ Thoughts
- Sadly, the 3 sample files demonstrating a benchmark between GC, atomic refcounts, and single-threaded refcounts has been lost to time.
- The
using
statement that he mentioned as a proposal was eventually implemented. - The
IDisposable
interface was implemented, and is now a core part of the .NET runtime. - A SO thread on this topic from 2009
- GC heap scan times are a real pain that microbenchmarks never capture. But GC technology has also improved over the years - concurrent GCs like G1 or Shenendoah in the JVM make this point moot.
- A lot has changed in the past 20 years wrt ref counting.
- C++ introduced
unique_ptr
andshared_ptr
in 2011, making Brian’s point about C++ programmers making bugs in ref counting obsolete. The brilliant idea was to have both types of pointers, to split ref counting into ownership and shared ownership. But even inshared_ptr
, the design is rather complex to allow forweak_ptr
, and to guarantee atomicity. - Rust’s ownership system has relegated memory management to a very tiny fraction of an average Rust program, making Ref counting feasibly for what’s left.
- Nim has figured out how to implement Move semantics without user annotations (see Nim’s arc memory management). This makes atomic ref counting largely unnecessary, which speeds up ref counting by quite a bit.
Email reproduced below:
Date: Fri, 6 Oct 2000 08:22:59 -0700
Reply-To: dotnet discussion<EMAIL_ADDRESS>Sender: dotnet discussion<EMAIL_ADDRESS>From: Brian Harry<EMAIL_ADDRESS>Subject: Resource management
I know people have been waiting a long time for someone at Microsoft to say something about the issue of resource management and deterministic finalization. Because this is such a sensitive topic I am going to try to be as precise and complete in my explanation as I can. I apologize for the length of the mail. The first 90% of this mail is trying to convince you that the problem really is hard. In that last part, I’ll talk about things we are trying to do but you need the first part to understand why we are looking at these options. Don’t get too depressed reading the first part it’s all background.
History
First, let me start with some history. A few years ago when this project first started we had a massive debate on this very issue. Some of the early contributors to this project came from the COM and VB teams, along with many other teams across the company. One of the big problems we set out to solve was to eliminate the issues with ref counting, including cycles and errors due to misuse. There were all kinds of anecdotes running around at the time about how team X used the last N months of their product cycle chasing down ref counting bugs. I suspect some of it was overblown, but nonetheless we believe that ref counting errors are reasonably common and providing a uniform solution is a valuable addition.
We initially started with the assumption that the solution would take the form of automatic ref counting (so the programmer couldn’t forget) plus some other stuff to detect and handle cycles automatically. We looked at adding conservative collection or tracing to the mix, GC algorithms that could collect a single object without doing an entire graph trace, etc. For a variety of reasons (more on this below), we ultimately concluded that this was not going to work in the general case. In those days the primary focus of our effort was in maintaining VB compatibility. The solution had to be complete and transparent with no semantic changes for VB. We eventually ended up with a context-based model where there was a “deterministic context” and everything in that context used ref counting on top of GC and anything outside just used GC. This avoided some of the type bifurcation issues described below but didn’t yield a particularly good story for fine-grained mixing of code between languages. Ultimately, as you all know, we decided to make a series of changes to the VB language to modernize it and make it more capable. As part of this decision we decided to drop the VB lifetime compatibility requirements. This decision also generally ended investigation into deterministic lifetime issues. In retrospect, I think we tied that issue a little too closely to VB semantics and should have instead turned the discussion to the broader issue of resource management. We are looking at it that way now, if belatedly.
In the beginning, I was one of the most vocal advocates of ref counting. We came up with a million arguments for why deterministic finalization was critical. However, during this time we have watched (and helped) hundreds of thousands of lines of code be written without deterministic finalization. Now I am convinced that substantial programs can be reasonably written and debugged without the system providing any automatic support. That said, I fully agree that it would be better if the system/language provided additional support. Without it, you must build the behavior into the contract of the objects (like calling the Dispose method).
on to a technical analysis of the issues…
Deterministic Finalization
The first thing I want to do is define what it is we are talking about and give some examples. Without going into details of the implementation, what we refer to as “deterministic finalization” means: immediately after an object is determined to be no longer used by the program, its termination code executes and releases the references it holds on other objects cascading the termination in a predictable and repeatable order through the graph of objects. Ideally, this would work for both shared and single use objects. The term “immediately” here is open to some interpretation. It’s actually not a promise about time at all (for example a context switch can happen and an arbitrary amount of time can pass). It really means that the thread that discovers a reference is no longer used executes the termination code before it does anything else. There are a variety of cases where we care about either timeliness or order of the execution of the termination code of related objects. The most common case is where the object represents a physical resource (like memory or files or …). But it generally applies in any case where there is contention. Some examples:
- Memory - freeing the memory for an object graph quickly returns the memory to the pool for use.
- Window handles - the footprint of the window object in the GC does not reflect the actual cost - there is some footprint inside the OS to represent the window and there may even be a limit (other than available memory) on the total number of window handles that can be allocated.
- Database connections - concurrent database connections are frequently licensed and therefore there may be a small (like you could actually count that high in a few seconds) number of them available. It is important that these be returned to a pool promptly so they can be reused.
- Files - since there is a single instance of a given file and exclusive
access is required for many operations (deleting, writing, etc) it is
important that file handles get closed very aggressively. The canonical
example goes something like this (in pseudo code):
1 File f = new File("c:\foo.txt"); 2 byte[] b = f.Read(); 3 File.Delete("c:\foo.txt");
- Window subclassing - On tear down, it’s reasonable to unsub-class window functions in Windows. It’s important that this happen after all of the messages have been sent to the window and therefore after any other termination code that sends messages to the window.
I could go on and on, but you get the point.
Ref counting collection
Ref counting does a reasonable job providing deterministic finalization in many cases. It is worth noting that there are quite a few where it does not. The most common cited example is cycles. In fact, straightforward reference counting never collects objects that participate in cycles at all. There are techniques to manage this and we have all learned them painfully but it is a very undesirable characteristic and a huge source of bugs. In addition, if you start remoting objects across apartments, you can get apartment reentrancy and thus introduce a great deal of “nondeterminism” in your program. Some would argue that as soon as you hand a reference to an object outside the immediate control of a tightly coupled program you have lost your deterministic finalization because you have no idea when or if that “foreign” code will release the reference. There are others who believe building a complex system that is very dependent on the order of termination of a complex graph of objects is an inherently brittle design and is likely to create a significant maintenance problem as the code evolves. I understand most of this is of little comfort because a reasonably constrained program written by a reasonably competent programmer does get the benefits of deterministic finalization.
Tracing collection
A tracing collector definitely makes some weaker promises than ref counting does. It is a somewhat more “lazy” system with respect to executing termination code. Objects have “Finalizer” methods that are executed when the object is no longer reachable by the program. Tracing has the advantage that cycles are not an issue. It also has the huge advantage that assigning a reference is a very simple move operation (more on this in a minute). The price that you pay for this is that there is no promise about termination code running “immediately” after a reference is no longer used. However, I think there is a bunch of confusion about what IS promised (caused largely by our docs and due to some bugs in the pre-release causing finalizers not to be called on shutdown :)). The truth is that for “well behaved” programs, the finalizers will be called for objects. An ill-behaved program is one that crashes or puts the finalizer thread in an infinite loop, etc. Our docs are overly cautious about promises in this respect. If you have an object with a finalizer, the system will call it. This doesn’t address the issue of deterministic finalization, but is important to understand that resources will get collected and finalizers are a very valuable way of preventing resource leaks in a program.
Performance
Before I get into an explanation of the reasoning, I want to cover performance. I have seen quite a lot of doubt about whether performance is relevant. I strongly believe it is. I believe that we must have some kind of tracing collector to handle cycles, which necessitates a big part of the cost of a tracing collector. I also believe that code execution performance can be substantially affected by the cost of reference counting. The good news is that in the context of all objects allocated in a running program, the number of those objects that really need deterministic finalization is small. However, below I’ll talk about why it is hard to isolate the cost to just those objects. Let’s look at some pseudo code for a simple reference assignment when using a tracing collector vs. ref counting:
tracing:
1a = b;
that’s it. The compiler turns that into a single move instruction and might even optimize the whole thing away in some circumstances.
ref counting:
1if (a != null)
2 if (InterlockedDecrement(ref a.m_ref) == 0)
3 a.FinalRelease();
4if (b != null)
5 InterlockedIncrement(ref b.m_ref);
6a = b;
This code is huge. The bloat is very high - bigger working set and the execution performance is obscenely higher, especially given the two interlocked instructions. You can limit the code bloat by putting all of this stuff in a “helper” and further increasing the length of the code path. In addition code generation will ultimately suffer when you put in all of the necessary try blocks because the optimizer has its hands somewhat tied in the presence of exception handling code - this is true even in unmanaged C++. It’s also worth noting that every object is 4 bytes bigger due to the extra ref count field, again increasing memory usage and working set.
Here are a few programs I have written that demonstrate the cost of this. This particular benchmark loops, allocating objects, doing two assignments and exiting the scope of one reference. As with any benchmark you can make a million arguments about whether it is valid or not. I’m sure someone will argue that in the context of this routine, most of the ref counting can be optimized away. That’s probably true, however this is intended to simply demonstrate the effect. In a real program, those kinds of optimizations are actually very hard if not impossible to do. In fact in C++, what happens is programmers make those optimizations manually and that leads to lots of ref counting bugs. I would argue that in a real program the ratio of assignment to allocation is much higher than this.
-
<<ref_gc.cs>> - the version which relies on the tracing GC.
-
<<ref_rm.cs>> - a ref counted version that uses interlocked operations for thread safety. Note there is only one thread and therefore no bus contention making this the “ideal” case. I’m sure with some tuning we could make it perform a bit better, but not a ton.
It is worth noting that VB has not historically had to worry about using interlocked operations for its ref counting (although VC has). This is because VB components ran in a single threaded apartment and where “relatively” guaranteed that only a single thread would be executing in them at one time. One of the goals we had for this version was to open up VB for multi-threaded programming and to get rid of the complexity of COM’s existing 7 or 8 threading models (I can enumerate them if you insist). So I believe the multi-threaded comparison is the correct one. However, just in case there are nay-sayers, I have included the version that doesn’t use lock prefixes. It is not nearly as slow as the multi-threaded version, but it is still quite a bit slower than the GC version.
-
<<ref_rs.cs>> - a ref counted version that assumes it is running in a single threaded environment.
Here are the numbers I got on my dual proc PIII-600:
ref_gc: 531ms
ref_rm: 3563ms
ref_rs: 844ms
The perfect solution
I think everyone agrees that the perfect solution is that every object in the system is cheap to allocate, use and reclaim and at the same time goes away in a deterministic, orderly fashion the instant the programmer believes he/she is no longer using it regardless of whether there are cycles or anything else. The only way I am aware of to accomplish this is to combine something like a tracing GC with something like ref counting. I believe the data shows that ref counting is too expensive to be used in a general purpose way for all of the objects in programming environment. The code paths are longer, and the code and data working set are larger. If you then combine this already high price with the additional cost of implementing a tracing collector to reclaim cycles, you are spending an exorbitant price for memory management.
We researched various techniques to improve the performance of ref counting. There have been reasonably high performance systems built on ref counting before. We surveyed the literature, but these systems accomplished the improved performance by giving up some of their determinism. I don’t remember the details because it was years ago and I didn’t do the research myself.
It is worth noting that C++ programs don’t do this. Most high performance C++ programs that use COM actually use C++ classes internally where the programmer is required to explicitly manage the memory. C++ programmers generally only use COM on the boundaries where the API is exposed to clients. This is a key characteristic that allows the programs to perform well.
I’m sure my argument here is not going to sway everyone in the world. All I can say is we did a bunch of benchmarking and profiling and ultimately concluded that the performance was unacceptable and therefore the solution unattainable.
The next best thing
OK, so you can’t have it all, but what about if you could just have deterministic finalization on those objects that you need it on? This is where we spent most of our time thinking. Again you have to remember that most of this was in the context of exactly duplicating VB6 semantics with our new system. Most of the analysis still applies but some ideas that we discarded a long time ago now look more palatable as a resource management technique rather than transparent VB6 lifetime semantics.
Our first hope was that there would be some way to simply mark a class as requiring “deterministic finalization” either with an attribute or by inheriting from a “special” class. This would cause the object to be reference counted. We investigated tons of different designs that included both subclasses of System.Object and changing the root of the class hierarchy to some other class that served to bind the ref counting world to the non-ref counting world. There are two basic issues that we couldn’t work around:
-
composition - Any time you take an object that requires deterministic finalization and store it in an object that does not, you have lost the determinism transitively. The problem is that this strikes at the heart of the class hierarchy. For example, what about arrays? If you want to have arrays of deterministic objects, then arrays had better be deterministic. What about collections, hash tables, …. The list goes on and on and before you know it, the entire class library is ref counted. The other alternative is to bifurcate the class library - have deterministic arrays and non-deterministic arrays, etc. We thought about this, but soon concluded you’d have two copies of the whole framework and that would be confusing, perform horribly (you’d have 2 copies of every class loaded) and in the end wouldn’t be practical. We could think of specific solutions to specific classes (like I think, although I can’t remember, that we came up with some way to make arrays work, but the solution just didn’t scale to the whole framework). The fundamental problem is that if a non-deterministic object contains a reference to a deterministic one, the system is not deterministic. We also considered outlawing it; simply having that be an error. Again we felt that you couldn’t write real programs under those constraints.
-
casting - A somewhat related issue is what about casting? Can I cast a deterministic object to System.Object? If so is it ref counted then? If the answer is “yes” than everything is ref counted. If the answer is “no” then the object loses determinism. If the answer is “it is an error” then it violates the fundamental premise that System.Object is the root of the object hierarchy. And what about interfaces? If a deterministic object implements interfaces, is the reference typed as an interface ref counted? If the answer is “yes” then you ref count all objects that implement interfaces (note System.Int32 implements interfaces). If the answer is “no” then you lose determinism. If the answer is “it is an error” then deterministic objects can’t implement interfaces. If the answer is “it depends on whether the interface is marked deterministic or not” then you have a bifurcation problem of a different sort. Interfaces aren’t supposed to dictate object lifetime semantics. What if some guy implemented an API that takes an ICollection interface (pick your favorite) and your object that implements it needs determinism but the interface wasn’t defined that way? You are screwed. This leads to further bifurcation. Everybody defines 2 interfaces, one deterministic and one not and implements every method twice. Believe it or not, we actually looked at what it would take to do this automatically and to automatically generate the versions of the methods (deterministic or not) as they were used. That whole line of thought deteriorated into immense complexity.
All of this led us to conclude that a really automatic and simple type modifier couldn’t be done. That said, there are some ideas below on how we could relax some constraints and get something that might be helpful.
If not types what about references?
OK, so if we can’t mark types and have it all just work, how about if I can mark a variable as ref counting the referenced object? We spent a little while talking about this and it has some nice characteristics. However there are two things that cause problems.
-
construction - Since the ref counted property is associated with the reference rather than the type it means ref counting isn’t initiated at construction.  You create an object and store it in an un-ref counted variable because you know it doesn’t need ref counting. You pass it to someone else who isn’t sure so he puts it in a ref counting variable which increments the ref count to 1. When his variable goes out of scope, the count is reduced to 0 and the object is terminated. The caller never knows what hit him. This is so fragile it’ll never work.
-
composition - Same kind of composition problems as above. How do you have a ref counted member variable in a class when you have no idea whether its users will ref count or not.
What about deterministic finalization and value types (structs)?
I’ve seen a lot of questions about structs having destructors, etc. This is worth comment. There are a variety of issues for why some languages don’t have them.
-
composition - They don’t give you deterministic lifetime in the general case for the same kinds of composition reasons described above. Any non-deterministic class containing one would not call the destructor until it was finalized by the GC anyway.
-
copy constructors - The one place where it would really be nice is in stack allocated locals. They would be scoped to the method and all would be great. Unfortunately, in order to get this to really work, you also have to add copy constructors and call them every time an instance is copied. This is one of the ugliest and most complex things about C++. You end up getting code executing all over the place where you don’t expect it. It causes bunches of language problems. Some language designers have chosen to stay away from this.
Let’s say we created structs with destructors but added a bunch of restrictions to make their behavior sensible in the face of the issues above. The restrictions would be something like:
- You can only declare them as local variables.
- You can only pass them by-ref
- You can’t assign them, you can only access fields and call methods on them.
- You can’t box them.
- Problems using them through Reflection (late binding) because that usually involves boxing.
maybe more, but that’s a good start.
What use would these things be? Would you actually create a file or a database connection class that can ONLY be used as a local variable? I don’t believe anybody really would. What you would do instead is create a general purpose connection and then create an auto destructed wrapper for use as a scoped local variable. The caller would then pick what they wanted to use. Note the caller made a decision and it is not entirely encapsulated in the object itself. Given that you could use something like the suggestions coming up in a couple of sections.
So what then? (Summary of problem statement)
I hope the above analysis convinces you that we have thought long and hard about this and have not been able to find a “magic bullet”. I wish there were one, but I can’t find it and I’ve watched dozens of other people wrack their brains. What I have listed here is, by no means, an exhaustive list of everything we have considered, but should give you an idea of how hard we have tried.
In summary:
- We feel that it is very important to solve the cycle problem without forcing programmers to understand, track down and design around these complex data structure problems.
- We want to make sure we have a high performance (both speed and working set) system and our analysis shows that using reference counting for every single object in the system will not allow us to achieve this goal.
- For a variety of reasons, including composition and casting issues, there is no simple transparent solution to having just those objects that need it be ref counted.
- We chose not to select a solution that provides deterministic finalization for a single language/context because it inhibits interop with other languages and causes bifurcation of class libraries by creating language specific versions.
The picture can’t possibly be that bleak. Clearly you can implement ref-counting yourself. Just add a member variable and a few methods and call AddRef and Release where you need to. Further, messing up ref counting isn’t quite as bad as it used to be because you won’t leak forever (forgetting to release) and you won’t crash (forgetting to add ref). The GC will be a back stop and make the object go away when it isn’t used any longer and keep the object alive (at least the memory) as long as you have any references whether or not you have a ref count on it.
Breaking down the problem and suggesting some solutions
There are really several different scenarios here.
First, let me go back to the statement of determinism. There is a distinction between objects that really need deterministic finalization and those for which the GC simply can’t accurately cost the footprint. Things like window handles, bitmaps, etc are actually fairly plentiful and the GC could do a darn fine job collecting them if it just knew what the actual cost to the OS was instead of the portion of the footprint that lives in the GC heap. In fact, internally in WinForms we have a class called HandleCollector which keeps track of all of the Windows handles of this type that we use and uses some metrics to decide when it is appropriate to provoke a GC (using the GC class) to cause collection to happen and clean up all of the unused handles. You can also simply provoke a GC in your resource acquisition logic whenever you fail to acquire the resources you need in the hope that the GC will free them up. In the last month, we have discussed formalizing some GC extensibility (in fact the handle collector is not tied into the GC in any way - you could write the same thing yourself) that would allow objects/classes to describe their cost model so that the GC can better decide when it is appropriate to do a collection. This does not solve the general problem of determinism because any time the number of allowed instances is small, the GC is WAY too big of a sledge hammer to tackle the problem.  Our current thinking is not to add this to the product at this time because people can do it themselves pretty easily. Designing an extensible and efficient cost model will be tricky and we can’t really add much value over what you can do yourself.
For those objects that really do need precisely timed termination logic, let’s look at what you can do yourself and then let’s ask ourselves what the system/languages can do to make it easier, less prone to error, less typing, etc.
First, we are discussing formalizing a design pattern that we already use within the framework. All of our resource classes already support a method called Dispose(). It is a public method that you can call at any time that will release the resources contained by the object. Think of it kind of like the c++ delete operator but it doesn’t actually free the memory, it just runs the destructor. We are considering making this an interface to help codify the design pattern and facilitate some language support as described below. The interface would look like:
1public interface IDisposable
2{
3 void Dispose();
4}
There are a couple of interesting scenarios: scoped locals and unscoped members. I discuss both below:
scoped locals - It is a fairly common pattern to have local variables that allocate a resource, use it and release it before the routine returns. The code you would write is below (note this too is pseudo code). Notice that you must manually call the Dispose method and you must put it in a finally to make it resilient to exceptions.
1foo()
2{
3 File f = new File("c:\tmp");
4 try {
5 byte[] b = f.Read();
6 } finally {
7 f.Dispose();
8 }
9}
It gets uglier if you have more than one resource:
1foo()
2{
3 File f = new File("c:\tmp");
4 try {
5 File f2 = new File("c:\tmp2");
6 try {
7 byte[] b = f.Read();
8 } finally {
9 f2.Dispose();
10 }
11 } finally {
12 f.Dispose();
13 }
14}
or a little better:
1foo()
2{
3 File f2;
4 File f = new File("c:\tmp");;
5 try {
6 f2 = new File("c:\tmp2");
7 byte[] b = f.Read();
8 } finally {
9 f.Dispose();
10 if (f2 != null) f2.Dispose();
11 }
12}
PROPOSAL - There is a proposal here to add syntax that would make this look
like the following. The compiler would effectively expand this code to to
the code above. Please understand that by telling you we are considering
this, I am making no commitment and this is not a spec. The IDisposable
interface I mentioned earlier would help the compiler disambiguate the
method to call at the end of the scope. I would like to get your feedback
on the idea however. Obviously there are subtle variations on the syntax
you can invent. We believe that this makes the very common design pattern
quite a bit more palatable.
1foo()
2{
3 using (File f = new File("c:\tmp")) {
4 byte[] b = f.Read();
5 }
6}
unscoped members - The scoped local variable problem is a very constrained problem. It does not begin to address unscoped lifetimes (like member variables of heap allocated classes). The case above also only covers single ownership and not shared ownership where no one piece of code knows definitively when an object is no longer used. Only something like ref counting can be used to solve this problem. Let’s look at the code you might write:
1public interface IRefCounted : IDisposable
2{
3 void AddRef();
4}
5
6// ref counted base class.
7class RefCountable : IRefCountable
8{
9 private m_ref;
10 public RefCountable()
11 {
12 m_ref = 1;
13 }
14 public void AddRef()
15 {
16 Interlocked.Increment(ref m_ref);
17 }
18 public void Dispose()
19 {
20 if (Interlocked.Decrement(ref m_ref) == 0)
21 OnFinalDispose();
22 }
23 protected virtual void OnFinalDispose()
24 {
25 }
26}
27
28// an example ref counted class containing resources.
29class Foo : RefCountable
30{
31 UnmanagedResource m_resource;
32 RefCountable m_refCounted;
33
34 Foo()
35 {
36 m_resource = ...; // acquire an unmanaged resource
37 m_refCounted = ...; // allocate another ref counted object.
38 }
39
40 // replace the currently contained ref counted object.
41 public void Bar(RefCountable r)
42 {
43 if (m_refCounted != null)
44 m_refCounted.Dispose();
45 if (r != null)
46 r.AddRef();
47 m_refCounted = r;
48 }
49
50 // clean up.
51 public void OnFinalDispose()
52 {
53 if (m_refCounted != null) m_refCounted.Release();
54 ...(m_resource);
55 }
56}
In theory, the compiler could hide some of the goo for you, giving you:
1// an example ref counted class containing resources with compiler help.
2class Foo : RefCountable
3{
4 UnmanagedResource m_resource;
5 RefCountable m_refCounted;
6
7 Foo()
8 {
9 m_resource = ...; // acquire an unmanaged resource
10 m_refCounted = ...; // allocate another ref counted object.
11 }
12
13 // replace the currently contained ref counted object.
14 public void Bar(RefCountable r)
15 {
16 m_refCounted = r;
17 }
18
19 // clean up.
20 public void OnFinalDispose()
21 {
22 ...(m_resource);
23 }
24}
You get the basic idea. I could do some complicated shared lifetime example, but I won’t. It is worth noting that what I have done here works fine with the “using” construct described above so you can use ref counted objects in both single use and unscoped lifetime patterns. This seems like a reasonable solution but it fails many of the transparency tests in the problem statement above. If you cast Foo to Object, you no longer have any clue that it needs to be ref counted. If you cast it to an interface, again you would not know the underlying object needed to be ref counted. Although, you could chose to define some interfaces to be inherited from IRefCountable and they could presumable be ref counted. The question I have is what if we put some syntax around this with those limitations and at least made it look good? Would that be good, or are those limitations damning?
SUMMARY/CONCLUSION
In summary, we could consider adding
- Extensions to the HandleCollector class for general use
- Language syntax like the “using” construct for scoped locals
- Syntax to formalize use of the RefCounted class
But none of these are substantially different or better than what developers can do themselves. They simply make the code smaller, cleaner and potentially less error prone (although that might be open to debate). The feedback we get from developers who are using the .NET Framework every day, including internal developers who have been coding on it for the last couple of years, is that a tracing GC with finalization is an effective solution to the vast majority of their needs.
To be clear we are very strongly leaning against doing anything for #3. We are not inclined to do #1 because it is so easy for you to do it yourself. We are closest to the border on #2 but I’d say we are slightly disinclined to do it, again because it is really not more than syntactic sugar and we are prioritizing shipping very high.
We generally hear requests for deterministic finalization from developers who are new to the platform and who are looking for mechanisms that mirror what they have used in the past. I hope you feel we have done an adequate job laying out the thinking and we’d love to hear your feedback.
There it is. It’s long and you probably will disagree with lots of it, but it’s a reasonable analysis (I think). I’ll probably spend the next 2 weeks of my life clarifying each of the points :)
Brian


Bartleby Review
(2012-2017) is a free and occasional leaflet of criticism and other writing published in Vancouver, Canada.
Edited, typeset and printed in Chinatown, this pamphlet is hand distributed from backpacks and by friends heading in the direction of bookshops and galleries. In Vancouver, we have many of what art historian William Wood described as “occasional critics”—the off-duty journalist or curator, the intrigued artist, writers and poets. He wrote this about Vancouver in 1990, and for the most part, it’s still the case. BARTLEBY reflects this condition in its range of contributors, through their respective writing styles, approaches to criticism and artistic practices or professions.
Our world is an especially curated one, BARTLEBY publishes writing that might otherwise be lost to the pruned paradigm. Melville's scrivener usually comes to mind too, but we practice his mantra ("I would prefer not to") only notionally. Our production certainly exercises a willful refrain from certain expectations of art criticism and publishing which may hinder the publication of, or distract from, writing simply as autonomous works of inquiry. These aspects are further touched upon in our first anthology, BARTLEBY REVIEW: 1–20.
Each issue is printed in editions of 80 and distinguished by the writer's choice of coloured paper. It is distributed to the following galleries and bookshops: ARTSPEAK (border of Chinatown and Gastown), OR BOOKSTORE (Gastown, near Victory Square), PULPFICTION (Main & Kingsway), PS VANCOUVER(Chinatown), READ BOOKS & EMILY CARR UNIVERSITY(Granville Island).
Bartleby Review will conclude its editorial activities after the publication of Issue 50.
Obituary to follow.
BARTLEBY REVIEW: 1–20, an anthology of the first twenty issues with an introduction by writer and critic Aaron Peck, designed by Charlie Satterlee.
BARTLEBY REVIEW: 21–25, a mini-anthology with an Editor’s Note from Steffanie Ling, commissioned by Project Space for the 2015 Los Angeles Art Book Fair
Out of Print ;)
BARTLEBY REVIEW: 21–40, the second anthology with an introduction by artist Peter Gazendam, designed by Jaz Halloran.
Amy Kazymerchyk
Bopha Chhay
Curtis Grahauer
D'Arcy Blake
David Morris
Emile Rubino
Ingrid Olauson
Jabari Jordan-Walker
Jacquelyn Ross
Kendra Sullivan
Madison Killo
Mitch Speed
Peter Gazendam
Setup Magazine
Scott Cohen
Sung-Pil Yoon
Tobin Gibson


Strict Contextual Escaping does not support Internet Explorer version < 11 in quirks mode. You can fix this by adding the text to the top of your HTML document. See http://docs.angularjs.org/api/ng.$sce for more information.
This error occurs when you are using AngularJS with Strict Contextual Escaping (SCE) mode enabled (the default) on IE10 or lower in quirks mode.
In this mode, IE<11 allow one to execute arbitrary javascript by the use of the expression()
syntax and is not supported.
Refer
CSS expressions no longer supported for the Internet zone.aspx)
to learn more about them.
To resolve this error please specify the proper doctype at the top of your main html document:
<!doctype html>


Robocon 2016
Project Description
CONTEST THEME: Clean Energy Recharging the World
The game of ABU Robocon 2016 is designed in order to create the awareness of efficient energy consumption and clean and renewable energy utilization. Each team has to build two robots; Eco Robot and Hybrid Robot. Eco Robot doesn’t have an actuator to drive. It receives the driving energy from Hybrid Robot. Eco Robot has to use only one steering actuator to control its direction, to track the path containing Slopes and Hills, River, and Down Hill. Besides providing driving energy to Eco Robot, Hybrid Robot has to take Wind Turbine Propeller from Eco Robot and climb up Wind Turbine Pole in order to assemble Wind Turbine.
THE TEAM
Mechanical
- Krishna Raj
- Animesh Mishra
- Vamsi Krishna
- Bijon Guha
- Jashan Singh
- Nitesh Arora
- Rajvardhan Singh
- Kshitija Saharan
- Arnab Roy
- Shivam Parashar
- Yamnesh Agrawal
Electronics
- Sparsh Gupta
- Aman Malhotra
- Prasant Shekhar Singh
- Raj Hans Gupta
- Mohit Gupta
- Peyush Jain
- Shaktiman Dubey
- Anmol Popli
- Pulkit Goyal
- Sushant Samuel
- Bhaskar Kaushik
- Nabarun Pal
- Aman Mehta
- Prabhpal Singh Seerha
- Gautham Sriram
- Shivam Srivastava
Marketing
- Amit Raj Gandhi
- Anshul Jain
- Abhishek Sachdeva
- Manthan Sheth


In 1983, a callow youth of just sixteen years, I performed in "The Zoo" and "The Pirates of Penzance" with the Glasgow Savoy Club. It was my first show outside of school.
Imagine my surprise when, after a fairly lengthy introduction, we started singing. I kid you not - we spent over twenty minutes on the word "Hail". And then more than ten minutes on "Po". Just before tea-time, we got to join them up, eventually this became "Hail Poetry"
I don't imagine there are many clubs where things are taken to that level of detail these days!
I remember being stunned by the quality and power of the voices there. It was the first time I had ever been unable to hear myself when I was singing, the singers around me were so good. And then came Kathryn Lloyd-Evans, a superb soprano who made Mabel sound both amazingly powerful and ridiculously easy. I was absolutely knocked out - she was superb!
Here are two scans from the only photo of this show that I have. The first one a group scene from "Pour Oh Pour The Pirate Sherry"
And the second, a close-up of me. Hey, it's a vanity site, remember?


Healthy:
Sick:
Recovered:
Deceased:
Welcome to your very own Disease Spread Simulator! Inspired by the works of Harry Stevens from the Washington Post
and Grant Sanderson on YouTube, I decided to create a program that allows users to explore disease spread in an interactive environment.
From social distancing to infection rate, you can simulate a variety of disease events from the
common cold (Recovery Time = Fast, Social Distancing = None, Infection Rate = 50%)
to the Bubonic Plague (Recovery Time = Medium, Social Distancing = Light, Movement Speed = Slow, Infection Rate = 90%, Fatality Rate = 60%) to our own
COVID-19 pandemic (Recovery Time = Slow, Social Distance = Extreme, Infection Rate= 75%, Fatality Rate = 2%).
Let me know if you enjoy the simulation or find a way to improve it!
Here are some descriptions for each of the variables you can play with:
- Number of individuals
- - These are all the dots seen on the screen. Be careful running the simulation with more than 1000 individuals. It may slow your browser.
You'll notice that when you have less than 300 individuals, they bounce off each other to better represent the infection rate.
If you more than 300 individuals, they just pass through each other, because repeatedly bouncing off deceased individuals in a community is just a little too morbid...
- Recovery Time
- - How long an individual stays "sick."
- Social Distancing
- - These measures force a certain amount of individuals to "shelter in place."
- Quarantine
- - Produces an impermeable barrier that prevents individuals from coming into contact with one another. The quarantine works best with fewer individuals.
- Movement Speed
- - How quickly individuals are moving around.
- Infection Rate
- - The probability that a healthy individual becomes ill after coming in contact with a sick individual.
- Fatality Rate
- - The probability that an individual dies from the disease.


Information Visualization
I worked with Lemeng XU.
Dec 2018 - Feb 2019
Design & coding
This is a tool to help researchers to visualize their data about a HCI experiment. The experiment is about how a user transist from menu to hotkey when selecting a command.
Emmanouil Giannisakis and Gilles Bailly, researchers at Sorbonne Université, are studying how people transit from menu selection to keyboard shortcuts. They have a dataset about how users' behavior changes regarding performance and strategy choice while they selected commands.
The goal of this visualization is to present the entire data set in a visual form so that they can observe and compare the data of each subject, and discover some common patterns.
We talked with Emmanouil and Gilles to know what the question is. They introduced the dataset to us and showed their past work. Then we found their main concern is about TRANSITION.
Since there are about 20k rows of data, the concept of our design is to divide it, first by subjects, then by commands and finally by trials. Different information is displayed according to the different views.
In the sketch phase, we used the 10 plus 10 method to come up some ideas. Based on a common starting point, group members work individually to quickly sketch several ideas each, making around 10 ideas per group. They share the ideas within the group and choose one sketch as the starting point for the next round.
The graphs in the first column are from the first phase. The other graphs are some variations.
Then we talked with them again about the first demo and our ideas. They liked it and wanted to see some high-level information. Then we add some new graphs and modified our design based on the first demo.
we used the color map of red, yellow and purple to represent different phases of transitions. Grey means no transition. Vivid colors are clear on the grey background and can attract user's attention.
The advantage of this layout is that researchers can compare the data of 42 subjects and go deep into the experimental data of each subject to seek subtle and interesting findings.
We decided to develop this visualization on web because it can be highly customized.
The interaction method is mouse and keyboard. Users can use mouse to select subjects and use keyboard to switch the subject they are viewing. Then we came up an idea to use the mouse cursor as an indicator showing the detail information.
The cursor moves on the line chart. The corresponding grid will be highlighted and information will be displayed.


README to HTML
Insert the link for the README.md you want convert to HTML:
Preview
Download
If you have local files linked in your .md file, the generated HTML will need to be placed on the same level as the original .md file to make use of the relative paths
2019 Henrique Figueiredo |
nf.henrique@gmail.com


Pull Requests gladly accepted
SOGo is an open-source, modern, scalable groupware server. It offers shared calendars, address books, and emails through your favorite web browser, desktop client, and mobile device.
SOGo is not an all-in-one solution like Microsoft Exchange (this is a good thing!). Instead, SOGo reuses many components in an infrastructure; particularly, the:
SOGo places an emphasis on scalability. Thus, several user-authentication methods are supported, whether:
SOGo will literally transform these loosely-coupled components into an efficient, integrated groupware solution, which can be accessed from (i) your favorite web browser; (ii) a variety of desktop clients; and (iii) mobile devices.
Follow the steps outlined in How To Create Your First DigitalOcean Droplet Virtual Server to deploy the latest release of an Ubuntu 12.04 server
.
SSH Keys
For increased security, it is advisable that you:
- Create your droplet with pre-installed SSH keys. See How To Use SSH Keys with DigitalOcean Droplets (Windows users: Refer to the article cited, next); and
- Disable password logins. See How To Create SSH Keys with PuTTY to Connect to a VPS.
Follow the steps in Initial Server Setup with Ubuntu 12.04 | DigitalOcean.
Set your server’s hostname and Fully Qualified Domain Name by implementing the steps in Setting the Hostname & Fully Qualified Domain Name (FQDN) on Ubuntu 12.04 or CentOS 6.4.
You can change your server’s timezone to whatever you want; altough it may be best to set it to the same timezone of most of your users. To do so, simply execute, in a terminal:
sudo dpkg-reconfigure tzdata
and follow the instructions in the ensuing on-screen prompts.
Add the SOGo repository to your apt-sources list
, by copying & pasting both lines, below, into the command line and pressing Enter
:
echo -e "deb http://inverse.ca/ubuntu precise precise \n\
deb-src http://inverse.ca/ubuntu precise precise" | sudo tee /etc/apt/sources.list.d/SOGo.list
Next, you must add SOGo’s GPG public key to Ubuntu’s apt keyring
. To do so, execute the following commands:
sudo apt-key adv --keyserver keys.gnupg.net --recv-key 0x810273C4
Then, update your lists of available software packages, by executing:
sudo apt-get update && sudo apt-get -y dist-upgrade && sudo apt-get -y autoremove && sudo reboot now
A convenient option for installing and configuring Postfix for SMTP-AUTH is to use Ubuntu’s mail-stack-delivery
package. The mail stack provides fully operational delivery with safe defaults and additional options.
Out of the box, the mail stack supports IMAP, POP3 and SMTP services with SASL authentication and Maildir as default storage engine. This package will install Dovecot and configure Postfix to use it for both SASL authentication and as a Mail Delivery Agent (MDA). The package also configures Dovecot for IMAP, IMAPS, POP3, and POP3S.
sudo apt-get -y install mail-stack-delivery
If you do not own a commercial SSL Certificate, you have two options:
Once you have an SSL certificate and key, execute:
sudo vim /etc/postfix/main.cf
Then, tap on the
i
key (on your keyboard) to enter the Vim text editor’s “insert mode.”
and change the following options:
smtpd_tls_cert_file = /etc/ssl/certs/mail.pem
smtpd_tls_key_file = /etc/ssl/private/mail.key
To save your edit, and exit, tap the following keys:
Esc
,:
,w
,q
,Enter
.
Finally, restart Postfix & Dovecot:
sudo service postfix restart && sudo service dovecot restart
Install SOGo by executing:
sudo apt-get -y install sogo
Next, execute:
sudo apt-get -y install postgresql sope4.9-gdl1-postgresql postfix-pgsql
Next, create the SOGo database in PostgreSQL. Start by switching to the PostgreSQL user:
sudo su - postgres
Then, execute:
createuser --no-superuser --no-createdb --no-createrole --encrypted --pwprompt sogo
The system will respond with the following request: Enter password for new role:
To which, enter sogo
. The system will then ask you to Enter it again:
. Do so and press the Enter
key. Then, execute:
createdb -O sogo sogo
Now, exit the postgres
user mode:
exit
Then, execute:
echo "host sogo sogo <IP_ADDRESS>/32 md5" | sudo tee -a /etc/postgresql/9.1/main/pg_hba.conf
Now, execute:
sudo vim /etc/postgresql/9.1/main/pg_ident.conf
Append the following to the end of that file:
mailmap dovecot mailreader
mailmap postfix mailreader
mailmap root mailreader
Then, execute:
sudo vim /etc/postgresql/9.1/main/pg_hba.conf
and look for the line that reads Put your actual configuration here
. Add the following, immediate after that line:
local mail all peer map=mailmap
Restart PostgreSQL:
sudo service postgresql restart
Switch to the PostgreSQL user:
sudo su - postgres
Execute the following commands, individually:
CREATE USER mailreader;
REVOKE CREATE ON SCHEMA public FROM PUBLIC;
REVOKE USAGE ON SCHEMA public FROM PUBLIC;
GRANT CREATE ON SCHEMA public TO postgres;
GRANT USAGE ON SCHEMA public TO postgres;
CREATE DATABASE mail WITH OWNER mailreader;
\q
sudo psql -U mailreader -d mail
\c mail
CREATE TABLE aliases (
alias text NOT NULL,
email text NOT NULL
);
CREATE TABLE users (
email text NOT NULL,
password text NOT NULL,
maildir text NOT NULL,
created timestamp with time zone DEFAULT now()
);
ALTER TABLE aliases OWNER TO mailreader;
ALTER TABLE users OWNER TO mailreader;
\q
You can now add virtual mailboxes, from the command line:
doveadm pw -s sha512 -r 100
Enter new password: ...
Retype new password: ...
{SHA512}.............................................................==
psql -U mailreader -d mail
INSERT INTO users (
email,
password,
maildir
) VALUES (
<EMAIL_ADDRESS>'{SHA512}.............................................................==',
'foo/'
);
Next, modify the SOGo configuration file to reflect the database settings, by entering each of the following commands individually:
sudo su - sogo -s /bin/bash
defaults write sogod SOGoProfileURL "postgresql://sogo:sogo@localhost:5432/sogo/sogo_user_profile"
defaults write sogod OCSFolderInfoURL "postgresql://sogo:sogo@localhost:5432/sogo/sogo_folder_info"
defaults write sogod OCSSessionsFolderURL "postgresql://sogo:sogo@localhost:5432/sogo/sogo_sessions_folder"
defaults write sogod OCSEMailAlarmsFolderURL "postgresql://sogo:sogo@localhost:5432/sogo/sogo_alarm_folder"
While still logged in as the sogo
user, we’ll continue configuring SOGo:
defaults write sogod SOGoTimeZone "America/Chicago"
defaults write sogod SOGoDraftsFolderName "Drafts"
defaults write sogod SOGoSentFolderName "Sent"
defaults write sogod SOGoTrashFolderName "Trash"
defaults write sogod SOGoIMAPServer "localhost:144"
defaults write sogod SOGoSieveServer "sieve://<IP_ADDRESS>:4190"
defaults write sogod SOGoSieveScriptsEnabled "YES"
If you want to allow users to add their own IMAP account in SOGo, add the following command:
defaults write sogod SOGoMailAuxiliaryUserAccountsEnabled YES
Logout of the sogo
user & return to your system user
exit
sudo apt-get -y install apache2
You have now to configure Apache2 by executing:
sudo vim /etc/apache2/conf.d/SOGo.conf
Next, add a hash to the following lines:
# RequestHeader set "x-webobjects-server-port" "443"
# RequestHeader set "x-webobjects-server-name" "yourhostname"
# RequestHeader set "x-webobjects-server-url" "https://yourhostname"
Enable the necessary modules for Apache2:
sudo a2enmod proxy
sudo a2enmod proxy_http
sudo a2enmod headers
sudo a2enmod rewrite
sudo a2dismod reqtimeout
Restart Apache2
sudo service apache2 restart
There is a small bug in the init.d
of Sogo that holds up the start-up process. You must edit the init
file:
sudo vim /etc/init.d/sogo
and add the -b
argument at lines 70 and 88:
#Line 70
if ! start-stop-daemon -b -c $USER --quiet --start --pidfile $PIDFILE --exec $DAEMON -- $DAEMON_OPTS
# Line 88
start-stop-daemon -b -c $USER --quiet --start --pidfile $PIDFILE --exec $DAEMON -- $DAEMON_OPTS
sudo service sogo restart
Any server accessible from the public Internet should be security hardened, and a groupware server is no exception. While security best practices are not within the scope of this article,
Change your SSH port from the default Port 22, as described in Step Five of Initial Server Setup with Ubuntu 12.04 | DigitalOcean, to a random port below 1024;
The default firewall configuration tool for Ubuntu is ufw
. To open the necessary ports, simply execute:
sudo ufw allow [custom SSH port below 1024]/tcp
sudo ufw allow 143/tcp
sudo ufw allow 587/tcp
sudo ufw enable
sudo ufw status verbose
Either disable password logins or deploy Fail2ban.
As always, if you need help with the steps outlined in this How-To, look to the DigitalOcean Community for assistance by posing your question(s), below.
Pull Requests gladly accepted


Jamie is a psychology PhD student based at the University of Sussex.
In the long tradition of “Hello world!” examples, this tutorial creates an experiment that outputs the phrase “Hello world!” to the browser. Though useless as an actual experiment, the process is helpful for learning the basics of using the jsPsych library. This tutorial will assume that you know very little about how to set up a web page.
Start by downloading the jsPsych library. The most recent version can always be found on the GitHub releases page.
Note: the image below shows version 4.2, but the process is the same for the most recent version.
Create a folder on your computer to put the experiment files in. Once you’ve created the folder, open the downloaded archive from step 1, and move the extracted folder (called jspsych-6.0.2
if using v6.0.2 of jsPsych) into the experiment folder. Here’s what it looks like on a Windows machine:
To edit jsPsych code you’ll need a programming-friendly text editor. Some free options are:
Once you’ve got a text editor that you like, create a new file in the experiment folder called experiment.html
There’s some basic code that (nearly) all HTML documents have in common. Here’s a typical bare-bones HTML document.
<!DOCTYPE html>

<title>My experiment</title>

Add the above code to the experiment.html file and save it. If you then open the file in a web browser, you should see a blank page and the title of the page will be ‘My experiment’.
To use jsPsych, add a

You may also want to import the jsPsych stylesheet, which applies a basic set of visual styles to the experiment to make it visually pleasing. This requires adding a <link>
tag to the
section of the document.
<!DOCTYPE html>

<title>My experiment</title>

<link href="jspsych-6.0.2/css/jspsych.css" rel="stylesheet" type="text/css"></link>

For the demo, we want to show some text on the screen. This is exactly what the jspsych-html-keyboard-response plugin is designed to do. To use the plugin, we need to load it with a

<link href="jspsych-6.0.2/css/jspsych.css" rel="stylesheet" type="text/css"></link>

Once the plugin is loaded, we can create an experiment using the plugin. To declare a trial that uses the html-keyboard-response plugin, we create a JavaScript object with the property type
equal to 'html-keyboard-response'
. Then we can specify the other parameters of the plugin in the same object.
To add JavaScript code directly to the webpage we need to add a set of

<link href="jspsych-6.0.2/css/jspsych.css" rel="stylesheet" type="text/css"></link>

Now that we have the trial defined we just need to tell jsPsych to run an experiment consisting of this trial. This requires using the jsPsych.init
function and specifying the timeline
parameter.
<!DOCTYPE html>

<title>My experiment</title>

<link href="jspsych-6.0.2/css/jspsych.css" rel="stylesheet" type="text/css"></link>

Once you’ve saved the file, open it in a browser. You should see “Hello world!” printed on the screen, and if you press a key on the keyboard, the text should disappear (ending the trial).


AP-Sync is a software library that makes sending data between Arduino and Processing easier. It works well with any size chunks of data with the right kind of hardware.
AP-Sync communicates between Arduino and Processing seamlessly through Serial tethering.
Both the arduino and processing need their respective copies of the library to work.
Installing the library on Arduino
Download AP-Sync for arduino
Extract zip file
Place Extracted folder with the name APsync to Arduino's libraries folder
Restart Arduino IDE if initially open.
Done.
Installing the library on Processing
Open Processing Sketch Import Library... Add Library...
On the contribution manager, Search for APSync.
Click on AP-Sync and click Install.
Done.
or
Download AP-Sync for processing
Extract zip file
Place Extracted folder with the name APsync to Processing's libraries folder
Restart Processing IDE if initially open.
Done.
Let there be AP-Sync
In both the arduino and processing sides, much like any other libraries on most programming languages, a library must be included/imported to be used.
Then an instance of AP-Sync can be created.
Arduino Side
Processing Side
Example Title
Arduino Side
Processing Side
Example Title
Arduino Side
Processing Side


On Friday, I responded to a question from a reader who wanted to know how many people had, like him, never had a drink of alcohol. After looking at trends within the U.S., I compared the percentage of lifetime abstainers in countries across the world using data from the World Health Organization (WHO). Luckily, being a health organization, WHO isn’t just interested in who is and isn’t drinking — it wants to know what’s in their glasses and how much they’re knocking back. It has national data on average alcohol consumption per capita for those age 15 and over in each country. The data also describes consumption by beverage type: wine, beer, spirits and “other.” To break consumption down by beverage, WHO again used government records as well as statistics from the alcohol industry and the United Nation’s Food and Agriculture Organization database.