Release History
Version 3.10 Release
New features and bug fixes for CBPlay.exe:
- Assign Ctrl-P hot key to start a Plotted Move, ESC cancels, and
Enter accepts.
- Added ability to use markers in a Plotted Move.
- Upgrade multiplayer feature to support up to 26 players. The prior
maximum was 8 players.
- Added ability to directly transfer ownership to another player.
Previously you had to release ownership and then assign ownership.
A possible use for this is to make it easy to pass a card to someone.
- Prompt and create multiple markers if dragged from marker tray while
holding the Ctrl key. For example: If the marker tray is set to deliver
random markers and the markers are graphical images of dice faces you
essentially have created a graphical die roller.
- Change piece X & X stagger maximums from 16 to 256. This is used by the
Autostack feature.
 The prior
maximum was 100.
- Added "Select All" and "Clear All" buttons to tray import dialog in
scenario editor.
- Added "Select All" and "Clear All" buttons to board selection dialog
in scenario editor.
New features for CBDesign.exe:
Version 3.03 Release
New features and bug fixes for CBPlay.exe:
- Added ability to rotate the selected group of markers and/or pieces around the selection's center point. This can be used to "wheel" as set of playing pieces.
- Added ability to rotate pieces and markers down to a single degree of resolution.
- Added hot keys for "Action / Rotate Object - Incremental" (Ctrl-Shift+R) and "Action / Rotate Group - Incremental"
(Ctrl-Shift+G) menu commands. You'll need to delete your CyberBoard CBPlay.exe registry key to get the new hotkeys to work.
To do this you can Double-Click on the provided "CBPlayRegDel.reg" file.
- If pieces and/or markers are selected then the view will be centered on the selections when using the zoom feature.
- The mouse wheel scrolls the view horizontally or vertically based on location of the cursor. If it's
near the upper or lower edge of the view, the mouse wheel will scroll the view horizontally. Otherwise
it's scrolled vertically.
- Bugfix: If the first action after starting a new move recording involved a random number (a die roll or a marker draw)
a fixed result was generated. Now the result is simply random.
- Bugfix: If an incremental rotation is the first action in a move recording, the incorrect game state is
stored in the move file. This caused a prompt to synchronize the game state when your opponent loaded the move file.
- Bugfix: Fixed the dialog used to enter text for pieces or markers to automatically wrap
text rather than horizontally scroll the edit box.
New features and bug fixes for CBDesign.exe:
Version 3.02 Release
Patch release that fixes launching files by double-clicking on them.
Version 3.00 Release
A revamped user interface including such features as:
- Dockable trays and markers.
- Tabs that allow direct selection of open windows.
- New XP menu style with icons.
- Customizable tool bars.
- Compatible with XP skins
New features for CBDesign.exe:
- 65536 color (aka 16 bit color) support. Along with the new UI framework,
this was a large chunk of the work for this release.
- Greatly improved color palette window:
- The first 3 x 8 area from the left are standard colors along with a grey scale.
- The next 6 x 8 area are the custom colors that can be set in a variety
of ways.
- The box to the right of the 6 x 8 area is the current color mix
created by changing the bottom Hue picker and the Saturation/Value
picker on the far right.
- The 48 custom colors are saved with the gamebox file.
- You can double-click on a custom color to adjust it using a color
setting dialog.
New features for CBPlay.exe:
Version 2.00 Release
New features for CBDesign.exe:
- GameBox files now support internal compression of bitmap images.
The GameBox file size can now be greatly reduced. Multiple levels
of compress are supported.
- GameBox files may now be password protected.
- The list of files recently opened (the so called LRU list) has
been increased to ten.
- When defining playing pieces there is an option allowing only the top
(active) side of a playing piece to be visible in select lists and
piece trays while playing a game. This is intended for implementing
playing cards.
- Top drawing layer objects now have the option to be drawn above the
grid. They are rendered in a second pass after drawing the grid.
This allows tables and such to be placed on the board and still
have the grid on top of some terrain features that are drawn using
lines and polygons.
New features for CBPlay.exe:
- Ability to associate text with pieces and markers.
- Ability to rotate markers.
- Piece and markers can now be locked so they can't be selected.
- Supports geomorphic construction of boards having hex style cells.
- Supports shuffling (randomizing) pieces in trays and on the
playing board. One application would be for playing cards.
- The game player program now remembers layout of open
windows in a game or scenario. The layout is restored when the
file is reloaded.
- Playing piece and maker trays now support several visibility
and behavior options.
- If you drag a marker out of a group that is set to deliver random
markers AND you hold the CTRL key when the mouse button is released,
you will be prompted for the number of random markers to be created.
This is great for actually "rolling" dice. Say a 5D6 where the
marker set is the six faces of a six sided die. This feature would
also be great for games that use pictures rather than numbers for
die faces.
- The board's selection list now includes markers.
- The board's selection list supports the use of the "Insert" and
"Delete" keys. These keys can be used selective remove objects
from the selection list. "Insert" keeps those highlighted in the
list. "Delete" removes those highlighted in the list.
- Markers now stack just like pieces.
- New "Auto Stack Deck" command that is used to stack selected items
using stagger values of zero.
- Toolbar buttons for plotted moves.
- The list of files recently opened (the so called LRU list) has
been increased to ten.
- The full path of the GameBox file is now stored in the Game file
so the GameBox can be in different areas of the file system than
the game file. This prevents your being prompted for its location
when loading the game.
Version 1.12 Release
New features for CBPlay.exe:
- A different style of cursor is displayed when you are recording a compound move.

- CBPlay.exe - The cell visibility setting of a playing board is imported from
the GameBox when adding new boards in the Scenario designer.
- CBPlay.exe - The auto-stack feature now properly saves and restores negative offsets.
- CBDesign.exe - The rotate tile option of the main menu no longer disables forever if
the project window is selected.
- Tiles in board cells that use the transparent color for the small
image now work properly.
- Various other small bugs.
Version 1.10 Release
- New icons for files and programs. These were done by Pokke (the same
fellow who did the CyberBoard logos on the Web page). They are much nicer than my artistically
challenged hacks. Sorry for the delay in getting these out Pokke!
- If the folder that contains CyberBoard is tagged as a system file then a
nice CyberBoard icon will show up in the Windows file explorer for that folder. The
batch file "CBIcon.bat" will do this for you.
New features for CBDesign.exe:
- Keyboard nudging of graphical objects within the board
editor. Note that this is the *FIRST* 3rd
party programmed feature addition for CyberBoard. It was
programmed by Donald McLean. Thanks Donald! A very cool feature. Here is the
key list:
- Arrow (up, down, left, right) nudge selected
components 1 pixel (or 1 grid width/length if
grid turned on).
- Shift-arrow scroll window.
- Control-arrow nudge and scroll.
- Alt-arrow nudge 5 pixels (or 5 grid widths/lengths).
- Alt-Shift-Arrow fast scroll.
- Alt-Control-Arrow fast nudge/scroll.
- Page scroll window one page up or down.
- Control-Page (up, down) scroll window one page
left or right.
- Home top of board.
- End bottom of board.
- Control-Home far left of board.
- Control-End far right of board.
- The cell layer now supports tiles that have transparent regions. For
backward compatibility this feature is off by default. To enable it for a
playing board check "Enable transparent tiles in cells" in the
Board Properties Dialog.
- You can now clone a playing board by right-clicking on the board name in
the project window and selecting the "Clone Selected Board"
command.
- The tile selection pane in the bitmap editor now supports scrolling so you can select
different tiles even when the full scale tile is really large.
New features for CBPlay.exe:
- The main playing area can now be split vertically and horizontally. Each
board view can be zoomed and scrolled independently. To use the feature
select the Window menu or right click on a board view.
- The select list and tiny board view can now be hidden. To hide them,
uncheck "Show select list and tiny board view." in the Board
Properties Dialog.
- The Scenario designer now supports automatically creating piece trays
from the piece groupings defined in the gamebox file. See the command
"Create Trays from Piece Groups..." on the "Project"
menu.
- The die roller now supports rolling multiple sets of the specified roll.
For instance, you could roll 50 2D6's at a time (if you're so inclined).
- The message view dialog now displays the entire history of messages that
have been viewed during playback.
- The message entry dialog now displays the entire history of messages
that have been entered during the current recording.
- A message can now be recorded without closing the send message dialog.
- If the pop-up map is too large for the screen it will be scaled down so
all of it is visible.
- If you chose to discard a
compound move, you are now prompted to verify your decision. This is to prevent accidental loss of moves.
- The delay between submoves of a compound move has been increased.
Bug fixes:
- CBDesign.exe - If you used the "Apply Cell Mask" feature in
the tile editor and cancelled the dialog the program would crash. This embarrassing
bug is now fixed.
- CBPlay.exe - Importing move files that contain no moves will no longer
enable the move stepping buttons. These buttons would cause the program to
crash if used.
- CBPlay.exe - names in marker tray are now alpha sorted.
- CBPlay.exe - Tiles that are greater than 255 pixels in height are now
truncated properly in lists. Note that due to a limitation in Windows
listboxes items larger than 255 pixels are not possible.
- CBPlay.exe - If the board cell grid is set to use very large cells in
messes up the auto-scroll code. This is now fixed.
Version 1.02 Release
Bug fixes:
- CBPlay.exe - The random number generator used for die
rolls has been completely overhauled.
- CBPlay.exe - Sort the tray name combo in the tray
palettes by name. Also doubled the length of the combo
box's drop down list.
- CBPlay.exe - Fixed rare crash that occurred when merging
move files with a new game created from a modified
scenario. It occurred when the "Use move game state
is selected" option was used.
- CBPlay.exe - Hitting the Close History button while moves
were in mid-playback caused the program to crash.
- CBDesign - If tiles are deleted that aren't being used
anywhere in the GameBox, don't consider it a major
revision. This prevents messages about the GameBox file
being newer than the game file when the file really is OK
for play.
- CBDesign.exe - When drawing on tile bitmap images with a
zero width pen nothing was rendered. Now the pen is
assumed to be one pixel.
New features for CBPlay.exe:
- The key "F9" toggles playing piece visibility.
This is handy for a quick check of the underlying hexes.
- The key "F10" toggles between showing move
indicator lines above the playing pieces or below them.
Version 1.01 Release
Bug fixes:
- CBDesign.exe - Sheesh!  This update
fixes it. Many thanks to Luca Saletti for reporting this
so quickly!
Version 1.0 Release
Here it finally is...a version with no time limits!
The file format has not changed from the final beta version.
Existing games and gameboxes will work fine.
Enjoy!
Beta 5.13 Board Editor Update Release Notes
Bug fixes:
- CBDesign.exe. Yet another bug exists in Beta 5.12 and
earlier versions of the designer program that could cause
a GameBox file to be damaged beyond repair. This is a
very rare bug that only rears its ugly head on GameBoxes
with many tiles of differening dimensions. Almost all
users of the software will not be affected sinze they
only use a small set of tile sizes. Those who have been
impacted no doubt know about it already (as far as I know
only one person was affected and I managed to repair his
GameBox).
Details:
The problem occurs when you hit an internal limit of the
program. CyberBoard internally stores tiles in bitmaps called
tile sheets. Tiles that are the same height and width are
stored in the same tile sheet. If the a tile sheet gets too
large I create a new tile sheet. CB supports up to 255 of
these tile sheets. If you exceed 255 tile sheets the problem
occurs. I never imagined in the early days of CB (in 16 bit
Windows) that more than 255 tile sheets would be needed.
To really fix this I need to expand the number of tile
sheets internally supported (which changes the GameBox file
format) but this will produce GameBoxes that are not
compatible with earlier versions of the program. For now,
Beta 5.13 expands the allowable size of each tile sheet and
more efficiently reuses tile sheets that are empty.
Beta 5.12 Board Editor Update Release Notes
Bug fixes:
- CBDesign.exe. A bug exists in Beta 5.11 and earlier
versions of the designer program that could cause a
GameBox file to be damaged beyond repair.  Almost all
users of the software will not be affected. Those who
have been impacted no doubt know about it already. This
is a good news / bad news fix:
The Good News
The bug is fixed. This bug has been in the program since
its first release. Basically CB tries to keep the size of
internal bitmaps (internally dubbed "tile sheets")
smaller than 4096 pixels high. A tile sheet contains tiles
that are all the same height and width. The code that checks
if a new tile sheet should be created was not working
properly. The result: bitmaps that can be much taller than
4096 pixels. GameBoxes that have exceeded this limit are OK
until they exceed 65535 pixels--a very unlikely event.
The Bad News
Any gameboxes that have tile sheets larger than 65535
pixels high are damaged for good. A rare occurrence but can
happen. Tile sheets that are larger than 4096 but less than
65535 will still work fine.
A thousand apologies for any trouble this may have caused
some folks.
Beta 5.11 Release Notes
This release was primarily made to provide a new date for the
program's "Time-Bomb".
Bug fixes:
- CBPlay.exe. If you used the window close button (X) of
the message reading dialog, no other messages in the
playback could be read.
- Both programs. Cyberboard files types are no longer
available on the Windows "New" menu (normally
seen by right clicking in the Windows Explorer).
CyberBoard doesn't support this feature.
- CBPlay.exe. Two sided playing pieces using different
sized tiles on each side didn't properly repaint when
flipped over.
- CBPlay.exe. When changing a playing board's zoom level
CyberBoard now tries to maintain the center of the view (if
possible). This should give more consistant results when
zooming in and out.
New features for CBPlay.exe
- There is a new board properties option called "Automatically
Show Board on Open". If this is checked, the board
will automatically be viewed when you open that Game or
Scenario file. (Happy Bart?)
Beta 5.10 Release Notes
Bug fixes:
- CBDesign.exe. Fixed a bug in the PolyGon drawing tool
that made it impossible to draw right and bottom areas of
a board. I accidentally introduced this bug in Beta 5.08.
Sorry about that!
- CBPlay.exe. The popup mini-board now can be dismissed
without affecting the main board. Either hit the ESC key
or click off of the mini-board window.
New features for CBDesign.exe
- The polygon board drawing tool functionality has been
extended to allow "free-hand" drawing. Just
hold the mouse button down and scribble.
- A new color changer tool has been added to the tile
editor. It works just like the paint bucket (flood fill)
tool except that all colors in the bitmap that match the
clicked color are changed to the new color.
New features for CBPlay.exe
- An "Indicators on Top" command has been added
to the "View" menu. Indicators are the lines
and boxes that indicate piece movement during playback.
- A "Single Step Compound Moves" command has been
added to the "Playback" menu. This command
allows you to step through a compound move to see every
piece of it.
Beta 5.08 Release Notes
Bug fixes:
- Fixed a NASTY crash bug in CBDesign.exe. The crash was
most likely to occur if a session of program use was very
long and you were doing a lot of bitmap editing (copies,
pastes, etc.). Basically the program was leaking bitmap
resources. When you close the program the resources were
reclaimed. In rare cases you could cause Win95 to operate
strangely since it would get resource starved. This
problem wouldn't show itself on Windows NT since NT
essentially provides an "unlimited" amount of
resources. This is why I never saw it--I do my program
development in Windows NT. A special thanks goes out to
Tim Cropley who reported the crash problem and worked
tirelessly with me to nail it. He gave very good bug
reports that helped me narrow the problem down. THANKS
TIM!
Beta 5.06 Release Notes
Bug fixes:
- Send message dialog. If you type text after rolling dice,
that text wasn't recorded.
- Die roller security hole. It has been pointed out to me (thanks
Paul!) that a person could simply type in text that looks
like a die roll to get the results they want. Duh. I'll
admit it never occurred to me. To prevent this, all lines
of text produced by the die roller now have a chevron
character (») prefixing
them. The editable areas of the send message dialog no
longer allow this character to be typed or pasted into a
message.
Beta 5.05 Release Notes
Bug fixes:
- The die roller was only r olling D6's. I'm very sorry for
that one!
Beta 5.04 Release Notes
New features for CBDesign.exe
New features for CBPlay.exe
- Die Roller. Yep...you heard right. I guess I can be
convinced to do something if I get hit in the head enough!
The die roller is integrated into the message send dialog.
When you roll dice the message edit area is converted into a
read-only part and an editable part. The results of the roll
as well as any message text typed thus far are transferred
into the read-only area to discourage "adjustments"
to the results. Also, the ability to discard the message is
thereafter disabled. If the roll had a problem the player
would need to inform the opponent via the editable message
area.
- A quick navigation feature has been added to the tiny
overview map. If you right click on the tiny map you'll
get a pop up version of it that you can click on to
quickly jump about in the main map window.
- Playback truncation. You can now discard the trailing
parts of a move playback. To use this, step to the place
in the playback that you want to use as the new starting
position of the game and select menu command "Playback/Accept
Move File Playback...". You will be presented with a
dialog that gives you the option of discarding the
remainder of the moves.
Truncating the move file playback is useful for recovering
from a hopelessly flawed set of moves. You would resume play
at the state of the game where the playback was truncated.
- When you are playing back a move file, the title and
description of the file are now associated with the
<Move File Playback> line of the project window.
- You can now save a bitmap image of a playing board
directly into a disk file.
- There is now a menu command that allows you to select all
markers that were created from a specific marker group.
This is useful for only deleting a specific class of
markers.
One use for this feature would be to have a marker group
that contains markers used to indicate a piece has moved. So
you would move a piece, mark it, move another piece, mark it,
and so on. When all your pieces are moved, use the menu
command "Select All Markers From >" and pick the
group that has the "moved piece" markers and hit
the delete key.
Bug fixes:
- F1 key now pops up the Help file.
- Using a "net" selection rectangle that clicks
on the lower right and drags to the upper left now works
properly.
- A weird bug related to exporting game history records to
a move file has been corrected. For the few people it
impacted the bug gave the appearance of saving a previous
move recording.
- Some problems with the snap grid, which occurred when
dragging multiple pieces, have been corrected.
- Other little nits...here and there.
Beta 5.01 Release Notes
Bug fixes:
- Problem with snap grid when dragging multiple selected
pieces. Now uses the piece clicked on for snap grid
reference.
- Loading history record caused complaint about a missing
playing board. If you get this message the game file is
probably corrupted. Save the game file as a scenario and
work from there. Problem is caused by too much text in
the scenario description.
- In half size board scale drags left artifacts if half
piece size was odd number of pixels.
- New Scenarios should inherit the snap grid settings from
the GameBox.
- When pieces are moved around on the playing board they
now remain selected.
Beta 5 Release Notes
This beta of CyberBoard contains all the features that will be
in the final release. I don't intend to add any more major
features before the first unrestricted version is posted.
New features for CBDesign.exe
- Context menus have been added to the right mouse button
for most of the windows in the program.
- You can now edit existing text fields on the map window
by selecting and double-clicking them.
- You can now copy an existing drawing layer bitmap to the
clipboard. Just select the bitmap on one of the playing
board drawing layers and use the Edit/Copy menu command.
- ToolTips have been added to the color picker window to
clarify its use.
- The board creation dialog now displays pixel dimensions
of a candidate board.
- Some small bugs.
New features for CBPlay.exe
- Context menus have been added to the right mouse button
for most of the windows in the program.
- A new way of specifying moves called Compound Moves
has been added. Compound moves allow you group an
arbitrary sequence of single moves so they are played
back as a single animated sequence of moves. For example,
you could move a piece, rotate it and move it again as a
single compound move. Upon playback your opponent will
see the move as a single animated sequence. The Actions
menu has the new commands for compound moves.
- A new way to rotate playing pieces called Incremental
Rotation has been added. Incremental rotation is done
directly on the board so you can see the exact piece
facing before committing to it. To do this, select a
piece and use the Actions/Rotate Piece - Incremental menu
command. You'll be presented with a popup window that you
can use to rotate the piece either clockwise or counter-clockwise.
- You can now step backwards through the moves during
playback. When you step back a move you'll see a replay
of the previous move.
- The small overview map can be used to jump around on the
main map view. The main view is centered on wherever you
click the mouse in the small map.
- You can now save the current state of game play as a
scenario file.
- Some small bugs.
Beta 4 Release Notes
This release of CyberBoard is mainly composed of bug fixes.
New features for CBDesign.exe
- You may now toggle whether or not the Select tool is
automatically reselected after drawing with another tool.
The toggle is available under the Project menu.
- You may now change the fingerprint of a GameBox. The
fingerprint is a unique numeric ID that enables Game
files to identify the GameBox they below with. The
probable use of this feature is to make a new GameBox
based on another GameBox. Once you change the finger
print the GameBox will not work with any scenario and
game files that were associated with them.
- Fixed bug in initial default snap grid values.
- Fixed bug that prevented app from being restored from a
minimized state if a palette window was open.
- Some small bugs.
New features for CBPlay.exe
- Fixed a NASTY bug that prevented games history records
from being loaded and replayed in pre-beta3 files. If you
double-clicked on a game history record and it didn't
work you were victimized by the bug.
- Fixed bug in initial default snap grid values.
- Fixed bug that prevented app from being restored from a
minimized state if tray or marker windows were open.
- Some small bugs.
Beta 3 Release Notes
New features for CBDesign.exe
- You can now save and load tile libraries (file extension gtl).
The file format is documented in file GTLFormat.txt
so programmer types can create ad-hoc tile generation
programs whose output can be directly imported into
CyberBoard.
To create a tile library select the tiles you wish to save
using the project window. Then use menu command Project/Save
Tile Library File to specify the filename. To load a tile
library select the tile group you wish to load the tiles into
(in the project window) and use the menu command Project/Load
Tile Library File.
- You can now specify fractions of a pixel when setting up
snap grids.
- Various adjustments to the menus.
- Bug Fixes.
New features for CBPlay.exe
- You can now save a bitmap image of the current game board
into a bitmap file.
- You can now specify fractions of a pixel when setting up
snap grids.
- Various adjustments to the menus.
- Bug Fixes.
Beta 2 Release Notes
New features for CBDesign.exe
- When working with Tiles in the project window you may now
select more than one in the list box.
- You can now copy tiles (Ctrl+C) selected in the tile list
shown in the project window onto the clipboard. You may
then paste (Ctrl+V) them into tilesets in any GameBox.
- You can now rearrange tiles in the tile window by using
the mouse to drag and drop them.
- You can now move tiles from one tileset to another by
using the clipboard. To do this: select and copy the
tiles you want to move to the clipboard (Ctrl+C) using
the tile list in the project window. Then select the new
tile set and use menu File/Move (Ctrl+M) to move them.
- Added toolbar button for leaving history playback mode.
The free form drawing layers of the board editor now
allow you to paste an arbitrary Windows bitmap from the
clipboard or a file directly onto the board. You can then
move it around as you would any drawing object.
New features for CBPlay.exe
- Added menu handling for accepting or discarding a
playback of a move file. This was and still is an option
available in the project window. It was put on the main
menu to make it easier to find and more intuitive.
- If the move file is accepted rather than discarded, the
moves are entered into the game history log and the final
board state (piece locations etc.) are now considered the
current state of the game.
- Added ability to copy a bitmap image of a complete game
board to the Windows Clipboard. One possible use would be
to paste the image into Windows Paint so you could print
it.


{% extends "base.html" %} {% block title_block %}Events - What is the PLAN?{% endblock %} {% block body_block %}
Events for PLAN 28 are currently as follows. If you have any questions or suggestions please email Computer Club RSO Email..


I am currently a fourth year studying Computer Science at the University of California, San Diego. I am an avid movie watcher, I love to eat everything, and I love to swim. I am an active member of Circle K International and I love to volunteer for the community as well as help those who are in need.
Before college, I never had any experience with computer science. After taking my first class, I loved it. So far, I have become familiar with C, C++, Java, Assembly, OCaml and a little of HTML and JavaScript. I am currently on track to graduate December of 2016. Right now, I am looking for an internship in order to gain real world experience as well as to further add onto my passion for computer science.


PSALMS 126
A psalm written for people going up to the temple to worship.
1 When Yahweh made Jerusalem prosperous again,
it was wonderful;
it seemed as though we were dreaming.
2 We were extremely happy,
and we continued shouting joyfully.
Then the other people groups said about us,
"Yahweh has done great things for them!"
3 We said, "Yes, Yahweh truly has done great things for us,
and we are very happy."
4 Restore us, O Yahweh, like the rains that fill the streams in the southern Judean wilderness.
Enable our nation to become great again like it was before.
5 We cried when we planted seeds because it was hard work preparing the soil that had not been plowed for many years;
now we want to shout joyfully because we are gathering a big harvest.
6 Those who cried as they carried the bags of seeds to the fields will shout joyfully
when they bring the crops to their houses at harvest time.


Cryptocurrency Series
Introduction
A purely peer-to-peer version of electronic cash would allow online payments to be sent directly from one party to another without going through a financial institution.
Part solution to this task is given by digital signatures, but the other half of the solution posed a major question in developing such systems - the part that requires a system to prevent double spending.
In the current centralized money tender distributed, this role of preventing the double spending is done by a centralized third-party authority. But in a peer-to-peer network this centralized server would not be available and thus would require a different methodology.
Bitcoin, proposed by Satoshi Nakamoto, was to solve this very problem on the peer-to-peer network. The network timestamps transactions by hashing them into an ongoing chain of hash-based proof-of-work, forming a record that cannot be changed without redoing the proof-of-work.
Current System
Current economy is based on trusted third-parties to process electronic payments. These systems suffer from the inherent weaknesses of the trust based model. Completely non-reversible transactions are not possible because banks cannot avoid mediating disputes.
Because of cost of mediation, the transaction costs are high which inturn limit the minimum practical transaction size thus cutting off the possibility of small casual transaction.
With the possibility of reversal, the need for trust spreads.
Proposed System
Bitcoin proposed a system where trust is replaced by cryptographic proof, allowing any two willing parties to transact directly without the need of a supporting trusted third party.
Computationally irreversible transactions prevent frauds.
Bitcoin proposed to tackle the issue of double-spending, using a peer-to-peer distributed timestamp server to generate computational proof of the chronological order of transactions.
The system is secure as long as honest nodes collectively control more CPU power than any cooperating group of attacker nodes.
Transactions
Electronic coin is defined as a chain of digital signatures.
A coin is transferred by an owner signing a hash of previous transaction and the public key of the next owner and adding these to then end of the coin.
The signature can be verified by the payee to check the chain of ownership.
The payee can still however not check for double-spending.
Traditional solution of this involves introducing a trusted central authority, or mint, that checks every transaction for double-spending. In such a system, after every transaction the coin must be returned to the mint to issue a new coin, and only coins issued directly from the mint are trusted not to be double-spent. This still does not solve the basic problem of dependency on company running the mint, which is basically serving the same purpose as that of a bank in the current system.
The only way to confirm the absence of a transaction is to have a copy of all the transactions. To accomplish this in a decentralized system, the transactions must be publically announced and there is a need for a system for participants to agree on a single history of the order in which they were received. So, at the time of the transaction, the payee needs a proof that the majority of the nodes agreed it was the first received one.
Timestamp Server
A timestamp server basically takes a hash of a block of items to be timestamped and widely publishes it, where the timestamp proves that the data must have existed at the time, in order to get the hash.
Each timestamp includes previous timestamp in its hash, forming a chain (blockchain), with each timestamp reinforcing the ones before it.
Proof-of-Work
A system to deter denial of service attacks and other service abuses such as spam on a network by requiring some work from the service requester, usually meaning processing time by a computer.
In case of bitcoins, the proof-of-work involves scanning for a value that when hashed along with the contents of the transaction blocks using cryptographic hashes such as SHA-256, gives a hash that begins with a specific number of zero bits. The average work required is exponential in the number of zero bits. Proof-of-Work is generally a problem that is fairly tough to solve but very easy to verify.
import time
import hashlib
import json
import matplotlib.pyplot as plt
transaction = [
'A paid B 25 A_public_key',
'A paid C 50 A_public_key',
'C paid B 10 C_public_key'
]
transaction = json.dumps(transaction).encode()
difficulty_bits = list(range(0, 8))
time_taken = []
for num_bits in difficulty_bits:
proved = False
proof = 0
start_time = time.time()
while not proved:
string = transaction + str(proof).encode()
current_hash = hashlib.sha256(string).hexdigest()
if current_hash.startswith('0'*num_bits):
print(current_hash)
print(proof)
proved = True
time_taken.append(time.time()-start_time)
proof = proof+1
plt.plot(difficulty_bits, time_taken)
plt.show()
"""
Outputs
-------
cb87ca935b8b44e94f5c670ecd375ba88ab7616aeab4c4c4369fe79e9c153f95
0
0c1d9b1549d14612571040e8352af4175a41b84a805a08880d3acdd5aad998be
5
00a51beea09d1fae73f3e18682445a3eb9bffc2cabf17f87f90f193c9eca1af3
396
00010ff4f55c002484ee13841be9a3c46aba3038a1046d604ac8cee7349a2228
514
0000a3c456eff341c9988b194231b02eb547a36a8134d095a5e1c4efb05dc7e3
22344
000002128ccfc4d1e662a6ceb8053860b887929b691c2f8506b0843e9a57fe34
3355879
000000bfc98081b9aff064455708d2d8fcc2afeac81b5a0b03a6fd926db1ce36
19659271
0000000cbd6302c37b40102ef55040e4315b63b39640110b679e033c44a8b2b0
310723836
Time Taken
----------
[0.0003619194030761719,
0.00020599365234375,
0.0012040138244628906,
0.0016019344329833984,
0.07679605484008789,
8.218470811843872,
47.986721992492676,
740.9898428916931]
"""
Basic needs of such system of proof-of-work are fulfilled by cryptographic hashes, that are often seen as one way functions, i.e. the only way to get the input given an output is to use the bruteforce approach and check all possible values of inputs and arriving at the correct candidate.
A nonce is an arbitrary number that can only be used once
In the bitcoin’s timestamp network, the proof-of-work is implemented by incrementing a nonce in the block until a value is found that gives the block the required number of leading zero bits.
Once the CPU effort has been expended to satisfy the proof-of-work, the block cannot be changed without redoing the work.
As the later blocks consume the hashes of previous blocks, changing a transaction in earlier block would require redoing the work for all the leading blocks.
Majority Decision Making
Proof-of-Work also gives a solution to determining representation in majority decision making. The majority decision is represented by the longest chain, i.e. the greatest proof-of-work. So if the majority CPU power is held by honest nodes, then the honest chain would grow faster and outpace any chain being proposed by a pool of attacking nodes.
To compensate hardware power and varying number of nodes over time, the proof-of-work difficulty is determined by a moving average targeting an average number of blocks per hour, i.e. if the blocks are generated too fast, the difficulty increases for subsequent blocks.
Network Protocols
Steps to run the network are as follows:
- New transactions are broadcast to all nodes.
- Each node collects new transaction into a block.
- Each node works on finding a difficult proof-of-work for its block.
- Upon finding the solution, it broadcasts the block to all nodes.
- Nodes accept a new block if all the transactions on it are valid and not already spent.
- Nodes express their acceptance of the block by working on creating next block in the chain, using the hash of the accepted block as the previous hash.
Nodes always consider the longest chain to be the correct one and keep on working to extend it.
If a node does not receive a block, it will request it when it receives the next block and realizes that it missed one.
Mining Incentive
By convention of the protocol, the first transaction of a block is a special transaction that starts a new coin owned by the creator of the block.
It is this, that acts as an incentive for the nodes to support the network, and provides a way to initially distribute coins into circulation.
Incentive can also be funded in the form of a transaction fees.
Incentive will also encourage nodes to stay honest. Because an attacker with more compute power would find it more favourable to play by rules and make more transaction fee, instead of competing with rest to fraud the system and invalidating his own wealth in the process by sabotaging the system.
Memory Optimizations
After the latest transaction is reinforced with several blocks stacking on top of it, the spent transactions can be discarded from the disk.
Transactions are hashed in a Merkle Tree, with only root included in the block’s hash.
A block header with no transaction is about 80 bytes, and blocks are generated every 10 minutes, then every hour about 6 blocks would be generated. So the total space required by blocks generated in a year would be about 4.2MB (i.e 80 bytes * 6 * 24 * 365). With the current capabilities of system memories, storage would not pose a problem to the system.
Payment Verification
The system makes it possible to verify payments without running the full network node.
Verification can be done by keeping a copy of the block headers of the longest proof-of-work chain, and obtaining the Merkle branch linking the transaction to the block it’s timestamped in.
By linking the transaction to a place in the chain, one can see if network nodes have accepted it by checking the proof-of-work, which would be further confirmed by blocks built on top of it in the chain.
Again, the verification is only reliable as long as honest nodes control the network. Because the simplified verification method can be fooled by an attacker’s fabricated transactions for as long as the attacker can overpower the compute resources of the unified honest nodes.
Combining and Splitting Value
Even though it is possible to handle each coin individually, it would be unweildy to make a seperate transaction for every cent in a transfer.
To allow value to be split and combined, transactions contain multiple inputs and outputs.
Usually, there is a single input from a larger previous transaction or multiple inputs combining smaller amounts, and at most two outputs: one for the payment, and one to return the change, if any, back to the sender.
Privacy
Traditional banking models achieve privacy through limiting access to information to the parties involved and the trusted third party.
In the proposed system, it is achieved by anonymizing the public keys that are used to sign a transaction. So, the public ledger can see someone is sending an amount to someone else, but without information linking the transaction to anyone (similar to tape in a stock exchange).
Some linking is still unavoidable with multi-input transactions, which reveals that the inputs originated from the same owner. So if one owner’s key is revealed, linking will allow to discover other transactions associated with that owner.
Mathematics of Bitcoin
If there were a scenario where an attacker is generating a alternate chain faster than the honest chain, it could still not generate value out of thin air or take someone else’s money because it will be rejected by the corresponding node which owns that token.
So all it is capable of doing is to double-spend its own money.
Basically the race between the honest chain and the alternate chain can be characterized as a Binomial Random Walk, where success event is honest chain being extended by a block and failure event is the alternate chain extented by a block gaining a lead on the honest chain.
In such a case, the probability of an attacker catching up with the honest chain by making up for the deficit can be modeled similar to a Gambler’s Ruin Problem.
The probability that the attacker ever reaches a breakeven is given by,
where,
- \(p\) is the probability of an honest chain extending
- \(q\) is the probability of a attacker chain extending
- \(q_z\) is the probability of the attacker catching up with the honest chain from \(z\) blocks deficit.
Given the assumption that the pool of honest compute power is greater than that of attackers, it is safe to assume that \(p \gt q\). So the probability drops exponentially as the number of blocks of deficit for an attacker increases. So after a fair lead, the probability of attacker to catch up is vanishingly small.
Time for Establishing Trust
Assume that the sender of a transaction is an attacker who wants to make the receiver believe that he paid him for a while, and switch it back to himself after sometime.
So initially the receiver will generate a new key pair and give the public key to the attacker for making the transfer. This prevents the attacker from preparing a chain of blocks in advance because of the dynamic nature of the public key generated.
So once the transaction is made, the attacker starts working on a alternate chain where the transactions are different.
Meanwhile the receiver waits for the transaction to be added to a block and another \(z\) blocks to be chained on top of that block.
The receiver does not know the progress of the attacker, but assuming the honest nodes took the average time to build a block, the attacker’s progress will be a Poisson Distribution with the expected value,
Probability that the attacker could catch up can be calculated by mutliplying the Poisson density for each amount of progress by the probability that he could catch up from that point, given by,
Rearranging to avoid infinite summation of the distribution,
import math
q = 0.1
p = 1-q
def factorial(k):
fac = 1
for _ in range(1, k+1):
fac *= _
return fac
def calculate(z):
lamda = z * q/p
sum = 1
for k in range(z+1):
sum -= math.pow(lamda, k) * math.exp(- lamda) / factorial(k) * (1 - math.pow((q/p), z-k))
return sum
for _ in range(0, 30, 5):
print(_, "\t=> ", round(calculate(_),8))
"""
Output
------
0 => 1.0
5 => 0.17735231
10 => 0.04166048
15 => 0.01010076
20 => 0.0024804
25 => 0.00061323
"""
Calculating the values, it is observed that the probability drops off exponentially with z.
Conclusions
- Bitcoin does not need a third party to enforce trust.
- Coin framework is based on digital signatures.
- A peer-to-peer network using proof-of-work records a history of transaction.
- Nodes can leave or rejoin the system according to their wish.
- Any needed rules and incentives can be enforced with this consensus mechanism.


| CONTENTS | PREV | NEXT | Java Remote Method Invocation |
The Java platform's distributed object model is similar to the Java platform's object model in the following ways:
- A reference to a remote object can be passed as an argument or returned as a result in any method invocation (local or remote).
- A remote object can be cast to any of the set of remote interfaces supported by the implementation using the syntax for casting built into the Java programming language.
- The built-in
instanceof
operator can be used to test the remote interfaces supported by a remote object.
The Java platform's distributed object model differs from the Java platform's object model in these ways:
- Clients of remote objects interact with remote interfaces, never with the implementation classes of those interfaces.
- Non-remote arguments to, and results from, a remote method invocation are passed by copy rather than by reference. This is because references to objects are only useful within a single virtual machine.
- A remote object is passed by reference, not by copying the actual remote implementation.
- The semantics of some of the methods defined by class
java.lang.Object
are specialized for remote objects.- Since the failure modes of invoking remote objects are inherently more complicated than the failure modes of invoking local objects, clients must deal with additional exceptions that can occur during a remote method invocation.


What? Camp who?
I like coffee. A lot. As spring approaches, I am also gearing up to head back outdoors. Camping and coffee don't always get along, however. That is, you can make some really good coffee when doing "plop and drop" camping, but if you're reducing the amount of kit you carry, your options start to get really limited.
With that in mind, I decided to take on the 'Camp Coffee' problem by well... trying all the coffee. For Science!
There were about 6 rounds involved in this, ranging from instant to stove top. Each produced hugely different results and what follows are my experiences with each. You'll note the 'stove top' was used here, as conditions outside weren't conducive to fire construction.
The rounds:
Note: Before we get too deep into this, I left out some of the standard options, travel french press, aeropress, etc. While you can pack those, they're also more or less known quantities / qualities.
Yes it's instant coffee. It is also everything that is wrong in the world, in the universe, all bundled up into one little package of crystallized hate. I mean, I suppose it's coffee, if you like aromatic gym socks and hints of industrial cleanser. This was the only one in the round up to make me spit and pour it out as fast as I could.
Quality: None. There was no quality here. Unless you are trying to get an oil stain out of your driveway I guess.
Trouble: All of it. All the trouble.
This stuff is magic. That is, after the old armpit socks from the last round, it was amazing how much like Folgers this tasted. Not sure if that is a compliment or not, but well, it was tolerable.
Quality: Only if I can't find VIA
Trouble: None
Nothing fancy here. Hot water, Coffee Powder, Stir. It is the stir part that will get you. Unlike the other two 'instant' coffees in the round up, this one uses a 'micro-grind' of sorts. Like cowboy below, don't drink the last sip.
 Yes, it's an American coffee staple. Yes, it's what I grew up on. Yes, it brings back the memory of that amazing trip to Bear Den campground in North Carolina where I brewed my parents a cup of coffee, and completely forgot the water. Apparently one can burn coffee.
The flip side of this is: I could totally see bringing a fire or stove top pot on a trip if I had a smaller one in my arsenal.
Quality: Alright
Trouble: Don't forget the water.
So I call this Cowboy rather than Turkish, as well, they're prepared almost the same: powdered coffee grounds, boiled in the water a few times. The differentiation here, is that Turkish generally calls for an almost equal amount of sugar to go with it. Brewing it was fast, but it was still a bit of trouble that is, having to schlep the grinder and the little Turkish pot thing. It was also gritty as heck. The slurry at the bottom should only be consumed if you need real ultimate power.
Quality: Good
Trouble: Medium
The stove top Mokka pot. This along with the percolator in round 4 is how I grew up drinking coffee. At my grandfather's house it'd be called "black" coffee and brought out around the holidays or when he was playing cards out by the pool with his buddies. It was often mixed with Sambuca around the holidays. I knew what to expect on this one. It was added to get an idea of the time vs trouble. It was a lot trouble, btw. Good for a plop and drop setup, but not so much if you need mobility.
Quality: Great
Trouble: A lot
Let it not be said there are not consequences to drinking 6 cups of coffee in less than an hour. With that, I'll likely go this season with either an Aeropress, Cowboy, or Via depending on packing requirements.


Collective Realms Magazine is a weekly fantasy and science-fiction magazine published by Lazy Adventurer Publishing. The magazine started in May of 2018 and is currently open for submissions.
Collective Realms Magazine has its origins in featuring short stories of the adventurers within the Collective universe, as seen in the blogs of the We Are Adventurers Tumblr community. The magazine now features short fiction and poetry by all authors, both emerging and established. In the magazine's stories and poems, readers can find fantasy and science-fiction of all sub-genres and cross-genres. We happily include magical realism, contemporary science-fiction, urban fantasy, and more.
The magazine was started by Andrew Olvera and Matthew Gustavson, who act as the magazine's duel editors-in-chief. Our grassroots literary magazine was created as Lazy Adventurer Publishing's first foray into the lit mag world. You can read Collective Realms Magazine online in its entirety for free in text form on our website. Additionally, each piece published receives a dramatic reading by a member of our team. These readings can be found on Spotify, iTunes, GooglePlay, and YouTube.
Staff
Andrew Olvera
- Editor-in-Chief, Publisher, Co-Founder
- Andrew Olvera (he/him) lives in Tucson, Arizona, where he works as a teacher for students with special needs. He is the co-founder of Lazy Adventurer Publishing and heads both press's magazines, Prismatica Magazine and Collective Realms Magazine as Editor-in-Chief and Publisher. His work can be found in the two magazines as well as Selcouth Station Press and Theta Wave Magazine.
Matthew Gustavson
- Managing Editor, Co-Founder
- Matthew Gustavson lives in Mankato, Minnesota where he lives with his son. He is the co-founder of Lazy Adventurer Publishing and managing editor for Collective Realms Magazine.
Rowan Withnell
- Poetry Editor
- Rowan Withnell is an award winning poet, short story, and tabletop supplement author. Currently she spends her time going between the US and England where she lives with her husband and spoiled cat. She also happily serves as poetry editor for both Prismatica and Collective Realms magazines.
Kay White
- Fiction Editor, Interviewer
Devin Hamilton
- Columnist, Editor
- Devin (she/her) is a writer obsessed with shadow, movement, and human interaction. She enjoys an overindulgence of coffee and wine in South Minneapolis. Sun Yung Shin awarded her with the Patsy Lea Core award in 2015. Her prose and essays can be read at Mookychic, Moonchild Magazine, and Occulum among other places. Devin and her twin sister run a Bookstagram where they geek out with other readers, and discuss why Hemingway talking about boobs is boring. London’s Ravenmaster liked her review of his novel.
Audrey Stolze
- Podcast Director, Host
- Audrey Stolze is a graphic designer, writer, podcaster, and editor. She is best known as the co-creator of Spaceships & Starwyrms, a sci fi 5e game. Audrey lives in STL with her husband and collection of houseplants.
Joshua Bratton
- Podcast Host
- oshua Bratton was born in Lakewood, Colorado and first fell in love with fantasy stories when his father read The Chronicles Of Narnia to him. From that point on, he read as many stories as he could get his hands on, which eventually inspired him to start writing such tales. He can be found on Twitter @jbratton1124 and on Tumblr at @kaleladin.
Edmund Withnell
Robbie Esson


Virufy on device detection for Covid-19
COVID-19 testing is inadequate, especially in developing countries. Testing is scarce, requires trained nurses with costly equipment, and is expensive, limiting how many people can obtain their results. Also, many people in developing countries cannot risk taking tests because results are not anonymous, and a positive result may mean a loss of work income and starvation, which further allows COVID-19 to spread.
Numerous attempts have been made to solve this problem with partial success, including contact tracing apps which have not been widely adopted often due to privacy concerns. Pharmaceutical companies have also accelerated development of experimental vaccines, but they still will not be widely available in developing countries for some time.
To combat these problems, we propose a free smartphone app to detect COVID-19 from cough recordings, which would allow for mass-scale testing and could effectively stop the spread of the virus.
We decided to use offline edge prediction for our app for several reasons. Especially in developing countries, Internet connectivity is limited and people often face censoring. Data privacy regulations such as GDPR are now commonplace and on-device prediction will allow for diagnoses without personal information or health data crossing borders. Because our app will potentially serve billions of predictions daily, edge prediction is also more cost-effective, as maintaining and scaling cloud infrastructure to serve all of these predictions will be costly and difficult to maintain.
System Design
In designing our system and pipeline, we first and foremost kept in mind that this pipeline would be running offline on edge devices in developing countries, including outdated phones with weak CPUs. We aimed for a pipeline that could efficiently process data, run a simple model, and return a prediction within a minute. To do this, we simplified our model, sacrificing some “expressiveness” in exchange for reduced complexity, but also through straightforward preprocessing of data.
- how
For the frontend, we decided on a web app because it can be used in the browser, which is operating-system-agnostic; in comparison, apps may only run on certain operating systems. Our frontend is written in ReactJS + TypeScript, which is the industry standard for modern web design. It employs responsive web design principles to be compatible with a wide range of screen sizes and aspect ratios present on different devices. Internally, the frontend calls a TensorFlow.js (TFJS) model for inference
We chose to use the TensorFlow.js (TFJS) framework because it is supported for use with web browsers. The TFJS Speech Command library provides a JavaScript implementation of the Fourier Transform (Browser FFT) to allow straightforward preprocessing of the raw audio files. We trained a vanilla TensorFlow model on background noise examples provided by the sample TFJS Speech Commands code, along with a dataset of thousands COVID-19 test result labeled coughs, so that our model could distinguish coughs from background noise. We then converted this trained model into the TFJS LayersModel format (with the model architecture as a JSON and weights in .bin files), so that we could integrate it into the front end JavaScript code for browser inference on-device.
Our system’s basic pipeline is as follows:
- User opens our app
- The TFJS models are downloaded from S3 onto the user’s device
- Microphone detects noise from user
- The Speech Commands library continuously preprocesses the audio by creating audio spectrograms
- The spectrograms are run through the model
- Only if the audio snippet is classified as a cough, the user will receive a prediction of whether they are COVID positive or negative
It is worth noting that model files are downloaded and loaded into memory only when the user first opens the app. After this, no Internet access is required and the system is able to make predictions offline.
>>>>> gd2md-html alert: inline image link here (to images/image1.png). Store image on your image server and adjust path/filename/extension if necessary.
(Back to top)(Next alert)
>>>>>
- This section details the key components of the system, including, but not limited to, data pipelines, modeling, deployment, and UX.
- If applicable, a diagram is included to illustrate the interplay between system components. Excalidraw is pretty awesome for sketches.
- This section explains and justifies central design decisions, including that of which technologies the team chose to use to support their system.
Machine Learning Component [Vivian/Solomon + Daniel]
The model that powers our application is based on the publicly available Tensorflow JS Speech Commands model. The model is intended to be used with the WebAudio API supported by all major browsers. This model expects, as input, audio data preprocessed with the browser FFT used in WebAudio’s GetFloatFrequencyData. The result of this FFT is a spectrogram which represents a sound wave as a linear combination of single-frequency components. The spectrogram, which can be thought of as a 2D image, is passed through a convolutional architecture to obtain logits which can be used in multiclass prediction. Specifically, this model has 13 layers with four pairs of Conv2D to MaxPooling layers, two dropout layers, a flatten layer, and two dense layers.
Because training from scratch is expensive, we started with a model trained using the Tensorflow Speech Commands dataset [2], trained to recognize 20 common words such as the numbers “one” to “ten”, the four directions “left”, “right”, “up”, “down”, and basic commands like “stop” and “go”. We performed transfer learning on this model by removing the prediction layer and initializing a new one with the correct number of prediction classes. Afterwards, we fine-tuned the weights on our own cough datasets such as the CoughVID open source dataset. The CoughVID dataset provides 20,000 crowdsourced cough recordings from a plethora of different characteristics not limited to gender, geographic location, age, and COVID status.
To ensure that data is preprocessed in the same way during training and testing, we use a custom preprocessing Tensorflow model which is trained to emulate the browser FFT that is performed by WebAudio, producing the same spectrogram as output. This browser-FFT emulating model is provided and maintained by Tensorflow Speech Commands.
Originally, we had been training with Teachable Machine [2], but found that they did not support custom training pipelines. Creating our own training pipeline lets us use optimized custom architectures and hyperparameters discovered through ongoing research efforts, such as in Fakhry (2021) [3].
- This section explains the ML model(s) that powers the application, the data it’s trained on, and the iterative development of that model.
- coughvid
- Google speech commands library
- preprocess
- what inputs mean, model architecture, pretrained
System Evaluation [Vivian/Solomon (ask Daniel)]
Offline evaluation was done on our model as a quick way to ensure our model was working correctly. This meant setting aside 30% of our data as test data. To monitor offline testing, we used Weights and Biases. As shown below, 50 epochs were sufficient to achieve convergence in training and validation accuracies, with corresponding decreasing losses. Here is an example of what we were logging:
The rest of the evaluation was done through real world testing. The gold standard of testing would be large-scale, randomized clinical trials, with data collected from a variety of demographic groups and recording devices. We did not have the time and resources to do that in this class; instead we did some informal evaluations on our own team members. In addition, we also enlisted the help of volunteers around the globe.
Anecdotally, the prediction was highly accurate on the group members, who are primarily Asian and all healthy. This remained true across a variety of devices such as smartphones, laptops, and tablets.
The collection of external results was complicated by ethical considerations and lack of access to PCR tests to provide ground-truth labels. Nonetheless, we will note here two cases in Brazil. One individual was recovered, but previously was diagnosed with COVID-19; the model predicted that he had COVID-19. The other individual had COVID-19, but was predicted to be healthy. This illustrates the inherent challenge of translating models from development to production; model accuracy might be highly degraded due to distribution shift between the training and inference data.
-
This section describes the team’s efforts to validate and evaluate their system performance as well as its limitations, both at instance-level and system-level.
in our test model/split performed XX%, sensitivity, false negative is important system-level test => covid negative reported for self tested on apple and android smartphones, wear a mask unit testing tested in hospitals of COVID positives (if Amil can do it)
-
The results are included and presented in a clear and informative manner.
graphs, weights and biases
Application demonstration [Amil]
In the beginning stages of the design process, our product designer determined the appropriate target audience by conducting user interviews. We selected potential interviewee candidates based on certain demographic criteria such as being a citizen of selected Latin America countries or being tech-savvy and owning a cell phone.
After gathering target audience candidates from 7 Latin America countries as well as the U.S. and Pakistan, user interviews were conducted. The results from the interviews were then synthesized to create user personas. These personas helped us produce empathetic and user-centered designs throughout the whole design process.
Once initial ideation and designs were completed, we conducted a series of prototype user tests in which the user is observed as they walk themselves through the app mockup. The data from each user test is then synthesized to design a new and improved iteration.
After numerous user tests and iterations and evolving over the past month, our designer created a finalized mockup of the demonstration application, choosing to build a web app because it works on all devices. Our customers are hospitals for initial testing, which will eventually expand to laypeople. We have made the instructions simple and easy to follow, as users just need to record their cough and they can immediately get their prediction.
>>>>> gd2md-html alert: inline image link here (to images/image2.png). Store image on your image server and adjust path/filename/extension if necessary.
(Back to top)(Next alert)
>>>>>
>>>>> gd2md-html alert: inline image link here (to images/image3.jpg). Store image on your image server and adjust path/filename/extension if necessary.
(Back to top)(Next alert)
>>>>>
Reflection [Everyone]
What worked? What didn’t work?
-
Teachable Machine
In the beginning, we had trouble dealing with some of the features in our model such as MFCC and mel-spectrogram as we tried to convert the model to TFJS. We further reached out to Pete Warden, expert of TinyML, about suggestions on how to keep everything on a smaller scale. This led to our first attempt of our system design using Teachable Machine, a web-based tool to create models. Teachable Machine uses Tensorflow.js to train models and then provides the code to integrate into JavaScript for a front end; it was simple and light. We soon discovered Teachable Machine was not that feasible however; it was difficult to feed in hundreds of examples for training because it required us to record your examples manually (therefore leading to poor performance), and we also wanted to know more what was actually going on in the training of the model and about the model itself. This ultimately forced us to train our own custom model.
-
Speech Commands Library
Tensorflow’s Speech Commands library provided a simple API to access a variety of important features like cutting the continuous audio stream into one-second snippets and performing FFT feature extraction to obtain spectrograms. The availability of pre-existing training pipelines as well as example applications using Speech Commands provided a strong foundation for us to adapt our own pipeline and frontend application.
One issue is that the Speech Commands library only processes .wav files. We ran into issues with converting between .wav files and .webm files, so had to run our own batch in order to deal with compatibility issues between different types of audio files, and consequently ended up with a smaller than ideal dataset.
-
Data
We had access to some more data such as the Coswara dataset, but did not have time to combine those with the CoughVid dataset we used.
-
Team Dynamics
We compartmentalized responsibilities such that individual members were largely in charge of separate components of the system. Frequent communication was key to ensure that we all had a sense of the bigger picture. Our primary mode of communication was Slack which allowed us to constantly check up on each other’s progress.
Overall, this experience taught us how to integrate the frontend and backend to build a Machine Learning system as well as utilize APIs and libraries to expedite the ML process.
If you had infinite time/resources, what would you improve?
- We would try to improve our model quality. Research suggests that 98% sensitivity is possible, which we currently fall below.
- Model development is limited by the lack of access to large-scale, demographically diverse, and accurately labelled datasets; we hope to remedy this in the future through improved data curation efforts.
- At the hardware level, it might be fruitful to calibrate individual microphones to reduce distribution shift between training and inference.
- Model evaluation in production is complicated by the need to account for different microphone characteristics of different devices.
- Exploring the effect of compression, mp3, etc. may lead to interesting insights.
- COVID-19 is not the only disease that affects one’s cough. We need to take into account various other diseases such as asthma, flu, and pneumonia, and distinguish between all of them (perhaps by using a multi-class classifier, or adding a class called “other”).
- If possible, we would like to support upload of recorded coughs in common video formats like Mp4, Wav, and Webm.
- Embedded devices may be something to look into, alongside making the model even smaller.
- This section provides a comprehensive post-mortem on the project, including - but not limited to - answering the following:
- What worked? (In terms of technology, design decisions, team dynamics, etc.).
- What didn’t work? What would you improve next time?
- If given unlimited time and resources, what would you add to your application?
- If you have plans to move forward with this application, what are they? (We’re always excited to see how students use the tools they’ve learned in this class to pursue topics they’re excited about!)
Broader Impacts [Amil]
Our app is intended to be used by people in developing countries who need an anonymous solution for testing anytime, or by anyone in a community at risk of COVID-19. However, we have identified some unintended uses of our app.
Because we intend to share our technology for free and because the algorithm runs on-device, competitors will be able to create copies of our app by stealing our algorithm, and may block access to the app or sell the app for profit when it is intended to be provided for free. To prevent this, we will open source our technology under terms requiring attribution to Virufy and prohibiting charging the users for use of the algorithm.
Another risk is that people may begin to ignore medical advice and believe only in the algorithm and might use the results in place of an actual diagnostic test. This is very risky because if the algorithm mispredicts, Virufy will be held liable, and the spread of COVID-19 may increase because COVID-19 positive people are confident to socialize with their false negative test results. To mitigate this, we intend to add disclaimers that our app is a pre-screening tool that should be used in conjunction with medical providers’ input. Additionally, we will work closely with public health authorities to clinically validate our algorithm and ensure it is safe for usage.
People may also start testing the algorithm with irrelevant recordings of random noises such as talking. To address this, we have equipped our algorithm with a cough detection pre-check layer to prevent any non-cough noises from being classified.
Finally, people especially in poorer contexts may share the same smartphones for several users, which can increase the likelihood of spreading COVID-19. Thus, our instructions clearly state that users must disinfect their device and keep 20 feet away from others while recording.
>>>>> gd2md-html alert: inline image link here (to images/image4.png). Store image on your image server and adjust path/filename/extension if necessary.
(Back to top)(Next alert)
>>>>>
>>>>> gd2md-html alert: inline image link here (to images/image5.png). Store image on your image server and adjust path/filename/extension if necessary.
(Back to top)(Next alert)
>>>>>
References [Amil]
[1] Tensorflow Speech Commands dataset, https://arxiv.org/pdf/1804.03209.pdf
[2] Teachable Machine, https://teachablemachine.withgoogle.com/
[3] Virufy: A Multi-Branch Deep LearningNetwork for Automated Detection ofCOVID-19 https://arxiv.org/ftp/arxiv/papers/2103/2103.01806.pdf
We’re extremely grateful to Pete Warden, Jason Mayes, and Tiezhen Wang from Google’s Tensorflow JavaScript team for their kind guidance on TinyML concepts and usage of the speech_commands library, both in class lecture and during the few weeks of our development.
Jonatan Jaskilioff and the team at XOOR were very gracious to lend their support and guidance in integrating our JavaScript code into the progressive web app they had built pro bono for Virufy.
We are also indebted to Amil Khanzada and the broader Virufy team for guiding us on the real-world applicability and challenges of our edge device prediction project. We leveraged their deep insights from their members distributed across 20 developing countries in formulating our problem statement. Additionally, we took advantage of the demo app that they had built prior based on intentions for real-life usage, along with their prior research findings and open source code for our model training.
In preparing our final report, we are grateful to Colleen Wang for her kind support in editing the content of our post, Virufy lead UX designer Maisie Mora for helping explain her design thinking and process in the application demonstration section, Saad Aslam for his kind support in converting our blog post to a nicely formatted HTML page, and Victor Wang for his kind support in reviewing our post for high-level audiences.
Finally, we cannot forget the great lessons and close guidance from Professor Chip Huyen and TA Michael Cooper who helped us open our eyes to production machine learning and formulate our problem to be attainable within the short 2 month course quarter.


Top diplomat implicates Trump in explosive impeachment testimony
WASHINGTON : The US military formally notified a court-martialed Navy SEAL commando on Wednesday that he faces proceedings to expel him from the ranks of elite special forces after his demotion was reversed by President Donald Trump, his lawyer and a Navy spokeswoman said.
A Trident Review Board hearing is set for Dec. 2 to weigh whether Special Operations Chief Edward Gallagher, who was charged with committing war crimes during a 2017 deployment to Iraq, is fit to remain in the SEALs, Navy Captain Tamara Lawrence said.
She told Reuters that three of Gallagher’s commanding officers face separate hearings to review whether they, too, should be removed from the SEALs. Gallagher’s civilian lawyer, Timothy Parlatore, confirmed his client was served with papers informing him of his review.


|
UMI3D Unity SDK
2.5.b.221125
A UMI3D sdk implementation using Unity
|
Interaction as a notification that will be displayed on the client browsers. More...
Classes | |
| class | NotificationCallbackEvent |
Public Member Functions | |||||
| UMI3DNotification (NotificationPriority priority, string title, string content, float duration, UMI3DResource icon2d, UMI3DResource icon3d) | |||||
| UMI3DNotification (NotificationPriority priority, string title, string content, string[] callback, UMI3DResource icon2d, UMI3DResource icon3d) | |||||
| ulong | Id () | ||||
| UMI3D Id of an entity. Null id is 0 Ids are set between 1 and 18,446,744,073,709,551,615. Actualy between 1 and 9,223,372,036,854,775,807 due to the serializer not sutporting unsigned values.
| |||||
| IEntity | ToEntityDto (UMI3DUser user) | ||||
Convert the entity to a DTO.
| |||||
| Bytable | ToBytes (UMI3DUser user) | ||||
Convert the entity to a list of bytes as a bytable.
Used in networking with bytes. More... | |||||
| virtual LoadEntity | GetLoadEntity (HashSet< UMI3DUser > users=null) | ||||
| Return load operation More... | |||||
| DeleteEntity | GetDeleteEntity (HashSet< UMI3DUser > users=null) | ||||
| Return delete operation More... | |||||
| void | OnCallbackReceived (NotificationCallbackDto notificationCallback) | ||||
| Called when the notification callback is received. More... | |||||
| void | OnCallbackReceived (ByteContainer container) | ||||
| Called when the notification callback is received. More... | |||||
| bool | LoadOnConnection (UMI3DUser user) | ||||
| Condition to be loaded on connection. More... | |||||
| bool | AddConnectionFilter (UMI3DUserFilter filter) | ||||
| Add a filtering condition from the user filtering. More... | |||||
| bool | RemoveConnectionFilter (UMI3DUserFilter filter) | ||||
| Remove a filtering condition from the user filtering. More... | |||||
| LoadEntity | GetLoadEntity (HashSet< UMI3DUser > users=null) | ||||
| Ask the clients to load the entity. More... | |||||
| DeleteEntity | GetDeleteEntity (HashSet< UMI3DUser > users=null) | ||||
| Ask the clients to delete the entity. More... | |||||
| IEntity | ToEntityDto (UMI3DUser user) | ||||
| Convert the entity to a DTO. More... | |||||
| Bytable | ToBytes (UMI3DUser user) | ||||
| Convert the entity to a list of bytes as a bytable. More... | |||||
| bool | LoadOnConnection (UMI3DUser user) | ||||
| Condition to be loaded on connection. More... | |||||
| bool | AddConnectionFilter (UMI3DUserFilter filter) | ||||
| Add a filtering condition from the user filtering. More... | |||||
| bool | RemoveConnectionFilter (UMI3DUserFilter filter) | ||||
| Remove a filtering condition from the user filtering. More... | |||||
| ulong | Id () | ||||
| UMI3D Id of an entity. More... | |||||
Public Attributes | |
| UMI3DAsyncProperty< NotificationPriority > | priorityProperty |
| Level of priority with which the notification should be considered. More... | |
| UMI3DAsyncProperty< string > | titleProperty |
| Syntehtic name of the notification. More... | |
| UMI3DAsyncProperty< string > | contentProperty |
| Textual content to provide more information. More... | |
| UMI3DAsyncProperty< string[]> | callbackProperty |
| UMI3DAsyncProperty< float > | durationProperty |
| How long the notification should be displayed. More... | |
| UMI3DAsyncProperty< UMI3DResource > | icon2dProperty |
| Icon to display. More... | |
| UMI3DAsyncProperty< UMI3DResource > | icon3dProperty |
| Icon to display. More... | |
| NotificationCallbackEvent | CallbackTrigger = new NotificationCallbackEvent() |
Protected Member Functions | |
| virtual NotificationDto | CreateDto () |
| virtual void | WriteProperties (NotificationDto dto, UMI3DUser user) |
Interaction as a notification that will be displayed on the client browsers.
| umi3d.edk.UMI3DNotification.UMI3DNotification | ( | NotificationPriority | priority, |
| string | title, | ||
| string | content, | ||
| float | duration, | ||
| UMI3DResource | icon2d, | ||
| UMI3DResource | icon3d | ||
| ) |
| umi3d.edk.UMI3DNotification.UMI3DNotification | ( | NotificationPriority | priority, |
| string | title, | ||
| string | content, | ||
| string[] | callback, | ||
| UMI3DResource | icon2d, | ||
| UMI3DResource | icon3d | ||
| ) |
| bool umi3d.edk.UMI3DNotification.AddConnectionFilter | ( | UMI3DUserFilter | filter | ) |
Add a filtering condition from the user filtering.
| filter |
Implements umi3d.edk.UMI3DMediaEntity.
|
protectedvirtual |
Reimplemented in umi3d.edk.UMI3DNotificationOnObject.
| DeleteEntity umi3d.edk.UMI3DNotification.GetDeleteEntity | ( | HashSet< UMI3DUser > | users = null | ) |
|
virtual |
| ulong umi3d.edk.UMI3DNotification.Id | ( | ) |
UMI3D Id of an entity. Null id is 0
Ids are set between 1 and 18,446,744,073,709,551,615.
Actualy between 1 and 9,223,372,036,854,775,807 due to the serializer not sutporting unsigned values.
Implements umi3d.edk.UMI3DEntity.
| bool umi3d.edk.UMI3DNotification.LoadOnConnection | ( | UMI3DUser | user | ) |
Condition to be loaded on connection.
| user |
Implements umi3d.edk.UMI3DMediaEntity.
| void umi3d.edk.UMI3DNotification.OnCallbackReceived | ( | ByteContainer | container | ) |
Called when the notification callback is received.
| container | Callback value as a boolean |
| void umi3d.edk.UMI3DNotification.OnCallbackReceived | ( | NotificationCallbackDto | notificationCallback | ) |
Called when the notification callback is received.
| notificationCallback |
| bool umi3d.edk.UMI3DNotification.RemoveConnectionFilter | ( | UMI3DUserFilter | filter | ) |
Remove a filtering condition from the user filtering.
| filter |
Implements umi3d.edk.UMI3DMediaEntity.
Convert the entity to a list of bytes as a bytable.
| baseSize | |
| user |
Used in networking with bytes.
Implements umi3d.edk.UMI3DLoadableEntity.
Convert the entity to a DTO.
| user |
Implements umi3d.edk.UMI3DLoadableEntity.
|
protectedvirtual |
Reimplemented in umi3d.edk.UMI3DNotificationOnObject.
| UMI3DAsyncProperty<string[]> umi3d.edk.UMI3DNotification.callbackProperty |
| NotificationCallbackEvent umi3d.edk.UMI3DNotification.CallbackTrigger = new NotificationCallbackEvent() |
| UMI3DAsyncProperty<string> umi3d.edk.UMI3DNotification.contentProperty |
Textual content to provide more information.
| UMI3DAsyncProperty<float> umi3d.edk.UMI3DNotification.durationProperty |
How long the notification should be displayed.
| UMI3DAsyncProperty<UMI3DResource> umi3d.edk.UMI3DNotification.icon2dProperty |
Icon to display.
| UMI3DAsyncProperty<UMI3DResource> umi3d.edk.UMI3DNotification.icon3dProperty |
Icon to display.
| UMI3DAsyncProperty<NotificationPriority> umi3d.edk.UMI3DNotification.priorityProperty |
Level of priority with which the notification should be considered.
Notification can be treated differently accoridng to their priority.
| UMI3DAsyncProperty<string> umi3d.edk.UMI3DNotification.titleProperty |
Syntehtic name of the notification.


MineSkin has already generated {{stats.total | number}} skins in total, {{stats.unique | number}} of which are completely unique!
In only the last 24 hours, MineSkin generated {{stats.lastDay | number}} skins,
which adds up to {{stats.details.lastMonth | number}} in the last month and {{stats.details.lastYear | number}} last year,
and {{stats.details.lastHour | number}} in just the last 60 minutes!
{{stats.details.genUpload / stats.unique * 100 | number: 0}}% of skins were uploaded, {{stats.details.genUrl / stats.unique * 100 | number: 0}}% were generated from an URL
and {{stats.details.genUser / stats.unique * 100 | number: 0}}% have been generated from other Minecraft players.
All the generated skins have been viewed {{stats.details.totalViews | number}} times in total.


|
genetics
|
Two stage index, first index ordered by value, second by address. More...
#include <two_stage_index.hpp>
Classes | |
| class | iterator |
Public Types | |
| typedef IndexArrayType::value_type | index_type |
| typedef AddrArrayType::value_type | addr_type |
Public Member Functions | |
| basic_two_stage_index () | |
| void | write_binary (writer &wr) const |
| basic_two_stage_index & | operator= (basic_two_stage_index &&rhs) |
| template<class Mapper > | |
| basic_two_stage_index (StringType &string, Mapper &map, typename Mapper::is_mapper *p=0) | |
| basic_two_stage_index (StringType &string, size_t num_indexed_chars) | |
| void | reindex () |
| size_t | end () const |
| iterator | find_inexact (const dna_string &search_str, size_t pos, size_t max_distance, size_t max_gap, bool is_brute_force) const |
| find the next dna string which is close to the search string allowing max_distance errors and max_gap gaps between exons. More... | |
| template<class charT , class traits > | |
| void | write_ascii (std::basic_ostream< charT, traits > &os) const |
| void | swap (basic_two_stage_index &rhs) |
Two stage index, first index ordered by value, second by address.
| typedef AddrArrayType::value_type boost::genetics::basic_two_stage_index< StringType, IndexArrayType, AddrArrayType, Writable >::addr_type |
| typedef IndexArrayType::value_type boost::genetics::basic_two_stage_index< StringType, IndexArrayType, AddrArrayType, Writable >::index_type |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
find the next dna string which is close to the search string allowing max_distance errors and max_gap gaps between exons.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |


Your choice: none
Computer choice: none
Victorious player: none
Number of games: 0
Wins: 0
Losses: 0
Ties: 0


Co-Founder / Interior Architect .
<EMAIL_ADDRESS>Co-Founder/ Industrial Designer
turgay@dexinar.com


The following is an example of lazy loading images (i.e. the process of not loading an image until it appears on screen)
We've purposely not initialised Imager yet, this is to show you what the placeholders look like before Imager has been run. You'll see the placeholders have a top margin (for the purpose of pushing them off screen, so we can make sure Imager is working properly) and also we've given them a top border of 1px red so you can visually see them.
To initialise Imager press the following button
We've also set the scrollDelay (i.e. the delay between scrolling and replacing a placeholder with an image) to be very high (two seconds). This is so you can visually see the lazy-loading of images as they happen.
The default value is 250ms but you can override that to your own preference.


'We can still get to Tokyo'- Black Meteors goalie Kwame Baah
Black Meteors goalkeeper Kwame Baah is confident Ghana will pick the final ticket to Tokyo 2020.
The Black Meteors will have to beat South Africa in the third and fourth play off to qualify for the Olympic games next year.
Ahead of Friday's game, the Asante Kotoko shot-stopper is beaming with confidence and believes the team are ready to secure the final slot for the continent.
"If you don't chase records, records can't be broken", We can still get to TOKYO. Let's believe again," he posted on Twitter.
Baah has been Ghana's safest pair of hands at the tournament and one of the outstanding goalies at the competition.
The 21-year old made the list of top three saves in match day three of the tournament, and his outstanding saves against Cote D' Ivoire kept the Black Meteors in the game for 120 minutes.
The ex-Inter Allies goalkeeper will be expected to do more if Ghana is to qualify for Tokyo 2020.
The Black Meteors have not qualified for the Olympic Games since Athens 2004.


Emi Sen started his journey in 2015 and joined Crome in 2016. Since then he earned
his ecxpertise in Hair Colouring and Beard. He is often called as "Beard Expert" and is fairly popular among
kids and teenagers.
Emi was awarded as the best employee of the year in 2017, he holds two Loreal
certificate and he is the only one holding expertise certificate by Beardo.


Installation
Required files
You need the following files provided by the release (example values)
-
The JAR file
(app-1.1.0.jar)
-
The knowlegdebase file
(kb-1.0.2.db)
-
The configuration file
(configuration.yml)
| The configuration file must be placed in the same location as the jar file |
Requirements
This program requires an installed java runtime version 11 or higher
Windows/Unix
Since it is a simple .jar file, which can run on any device featuring Java, you can run it by simply doubleclicking.
Docker
Dockerfile
If you can use a dockerfile, you can create one like this: Note to self: Need to test this!
FROM openjdk:15-jdk
MAINTAINER Cuupa
WORKDIR /opt/app/classificator
ADD https://github.com/Cuupa/classificator/releases/download/1.1.0/app-1.1.0_Release.jar /.app.jar
ADD https://github.com/Cuupa/classificator/releases/download/1.1.0/kb-1.0.2.db /.knowledgebase/kb-1.0.2.db
COPY knowlegebase/*.db ./knowledgebase/
COPY *.jar ./app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "./app.jar", "--server.port=8080", "--knowlegde_base=./knowlegebase/kb-1.0.0.db"]
Please change the port of the application and change it accordingly.
Synology NAS
-
Create yourself a folder, where you upload the files to
-
Download the openJDK container
-
Create a new container from this image
-
Give this container a name to your likings and click on the 'Advanced Settings' button
-
Mount your folders and files to the docker container. It is also a good idea to change this to "read only" mode, as this program does not change these files
-
Change the ports to your liking
-
Go to the environment tab and paste this as command to run:
java -jar /opt/classificator/app.jar '--server.port=8081' '--knowlegde_base=/opt/classificator/knowledgebase'
Finally, run this container. You can access the webui by going to http://your-nas-ip:your-port
For
example http://<IP_ADDRESS>:8081
Configuration
This is the default configuration of the application
It sets the server port to 8080 and the knowledgebase-directory to build/knowledgebase
---
classificator:
knowledge_base: build/knowledgebase
monitor:
username: "John"
password: "Doe"
enabled: true
logText: true
database_name: "monitor.db"
Server port
The default port of this application is 8080
So if you want to access the webUI on your local machine navigate to https://localhost:8080
. If you want to change that port, see Changing via command line arguments
Knowledgebase
This entry means, that there has to be a folder named build/knowlegebase
beside your jar file. You can specify which
knowledgebase to use, by changing it via the command line arguments (How that works will be covered by me
a few lines down below).
|
If this entry only contains a folder name without the specific knowlegedbase, it will load the file with the highest version tag in that folder For example if you have kb-1.0.0.db and kb-1.0.1.db it’ll load the kb-1.0.1.db
|
knowlegde_base: build/knowledgebase
Monitor
The monitor is enabled by default and uses the database monitor.db
monitor:
username: "John"
password: "Doe"
enabled: true
logText: true
database_name: "monitor.db"
Username and password
These entries set the username and password for accessing the statistics under /monitor
Database name
The database name is defined via database_name
. You can change it to your likings. It uses relative paths by default. If you want to use absolute paths, change it to
database_name: "C:\Users\John Doe\monitor.db"
Enabled and logText
If enabled
is set to true
, all events will be logged. To turn it off, set it to false
.
If logText
is enabled, the actual analyzed texts will be logged into the database. You might want to turn it off for privacy reasons, but it really helps finding errors in the classification process.
Changing
| If you use the command line arguments, the corresponding entry in the configuration.yml will be overwritten |
Via config
If you want to change the configuration, just edit it with any text editor and change it to your likings
knowlegde_base: knowledgebase/kb-1.0.0.db
or
monitor:
logText: false
Save the file and restart your application.
| Changing the config file and restarting the application is the recommended way of changing program parameters. |
Via command line arguments
You can also use the command line arguments
| The server port can only be changed by using the command line arguments |
java -jar app.jar --server_port=8080 --knowledge_base=knowlegebase/kb-1.0.0.db --classificator.monitor.logText=false
|
The first part simply runs the jar by the name "app.jar" |
java -jar app.jar
| This part sets the port to 8080 and overwrites the value of the default configuration |
--server_port=8080
| This part sets the location of the knowledgebase. You can use relative paths like |
--knowledge_base=knowlegebase/kb-1.0.0.db
| or absolute paths like |
--knowledge_base="C:\Users\John Doe\knowlegebase\kb-1.0.0.db"
| Notice that, you need to quote the value as soon as you have spaces in a parameter |
Components
Engine
The engine is the core component of this application.It classifies the text and extracts the metadata
Using the GUI
You can use the gui exposed at http://address-of-your-server:port
You can type in or paste the text to the left-hand textarea, which the engine shall analyze and hit the "Submit"-Button.The result will be presented in the right-hand area
Using the REST-API
The engine exposes several methods for analyzing the input text.The most simple one receives the text as a string and returns a List<SemantikResult>
The endpoint-path is:
"/api/rest/1.0/classifyText"
If you want to analyze anything except plain text the method accepts any byte array and uses a combination of PDFBox
and Apache Tika
to extract its contents for you.
"/api/rest/1.0/classify"
| There’s also a method for pinging the application. This method simply returns a HTTP/200 |
"/api/rest/1.0/ping"
How it works
If no text is provided, the engine simply returns an empty result. Otherwise the text is processed in several steps.
The Knowledgebase
The knowledgebase is just a simple 7z archive, containing descriptions of the topics, the senders, the metadata and regexes.
The topics, senders and metadata may contain any number of following tokens:
-
All
-
Not
-
OneOf
-
WildcardBefore
Example of a topic:
BILL = {
oneOf("rechnung","jahresrechnung","Zahlung der","zahlen Sie den Betrag","Rechnungs-Nr","rechnungsbetrag"),
oneOf("eur, "euro", "€"),
not("beitragsrechnung"),
not("dauerauftrag", "quittungsbeleg"),
not("versicherungsschein", "versicherungs-nr"),
not("gehaltsabrechnungen"),
not("rechnung trägt"),
not("keine Zahlung erhalten"),
not("jahresdepotauszug")
}
Example of a sender:
Rundfunk Beitragsservice = {
oneOf("Deutschlandradio"),
oneOf("BEITRAGSSERVICE"),
oneOf("ARD", "ZDF");
}
Example of a sender:
$IBAN = {
oneOf("IBAN: [IBAN]", "IBAN [IBAN]")
}
| The value inside the [] brackets is the file name of the regex definition, which shall be injected |
Example of a regex:
[a-z]{2}[0-9]{2}[\s]?[0-9]{4}[\s]?[0-9]{4}[\s]?[0-9]{4}[\s]?[0-9]{4}[\s]?[0-9]{2}
The regular expressions are case insensitive
|
Text normalization
This step is mandatory for all but metadata.
The text is converted to all-lowercase, whitespaces are replaced with a blank
and characters like "ä" are replaced with "ae"
private fun normalizeText(text: String): String {
return text.toLowerCase()
.replace(StringConstants.tabstop, StringConstants.blank)
.replace("\n\r", StringConstants.blank)
.replace("\r\n", StringConstants.blank)
.replace(StringConstants.carriageReturn, StringConstants.blank)
.replace(StringConstants.newLine, StringConstants.blank)
// text = text.replace("-", StringConstants.BLANK);
.replace(",", StringConstants.blank)
.replace(": ", StringConstants.blank)
.replace("€", " €")
.replace("Ãœ", "ae")
.replace("ä", "ae")
.replace("ã¼", "ue")
.replace("ü", "ue")
.replace("/", StringConstants.blank)
.replace("_", StringConstants.blank)
.replace(RegexConstants.twoBlanksRegex, StringConstants.blank)
.trim()
}
| Text which is parsed to extract the metadata will not be normalized |
Finding Topics
This step is the most simple one.
First of all the text is normalized like described above.
Then, it’ll be passed through each token for that topic like NOT
and OneOf
.
The token tries to find its value like "awesome" in the text using the Levenshtein-distance
.
The Levenshtein-distance computes the difference between the text and the tokenvalue itself.
| "awesome" and "awesome" results in a distance of 0, where "awesome" and "awsome" has a distance of 1, whereas the number represents the number of changes for one string to become equal to the other string |
If the distance is less than 2 (so a distance of 0 or 1) it matches. This is done to counter OCR errors (like mistaking a lowercase-"L" for an uppercase-"i")
Finding Senders
Finding senders is a 2 stage process. In the first stage, the sender defintions inside the knowledgebase are matched against the text which should be analyzed. If a sender is found: great!
If no sender is found, the text ist processed by the second stage. The engine tries to match the defintion
$sender = {
oneOf("[SENDER]")
}
with the regex
((?!(Ihre|Handelsregister|Die)))[a-zA-Z0-9]{1}[0-9& a-zA-Zäöü\-]+ (AG|a\.G\.|GmbH|SE|OHG)
| This regex is only valid for german companies |
Being a relatively coarse regex, this will match more words than the actual company name may be.
To determine the actual sender, the matched regex result is weighted by number of occurences in the text * number of words matched
Finally the sender is determined by removing all matches with 5 or more blanks
and returning the result with the most occurences in the text as the final sender.
Finding Metadata
Extracting the metadata is the most costly operation of all recognition, because of the ability to use regex and the need of recompiling the metadata defintions for every call.
Every result then is normalized like inserting spaces in an IBAN.
Monitor
The monitor is a statistical tool for getting informations on topic distributions, execution time and a history of processed texts with the recognized results etc.
Currently, theres pie charts for topic and sender distribution, a line chart for execution time and a table with the history.
The table consists of the columns:
-
Knowledgebase version
-
Received
-
Processing Time
-
Topics
-
Senders
-
Metadata
-
Analyzed Text
-
Download
| The analyzed text is only persisted if you enabled it via the config file |
The download column provides a link for saving this specific entry as a CSV file in case of reproducing classification errors etc.
|


--- layout: post title: Sweet Memories Cowl Pattern date: 2012-08-13 11:33:55.000000000 -04:00 categories: - Craft - Knitting - Patterns tags: - Cowl - Easy knit - easy knitting pattern - Free cowl pattern - Free knitting pattern - Zara chine yarn status: publish type: post published: true meta: aktt_notify_twitter: 'no' _edit_last: '1' dsq_thread_id: '1184278302' author: login: cint email<EMAIL_ADDRESS>display_name: Jacinta first_name: Jacinta last_name: '' ---
I'm so excited to share with you my Sweet Memories Cowl pattern. It was my mystery project from Yarn Along last week. Best of all, it's free! It's nice and easy and knits up quickly. It is long enough to wrap two or three times. I think cowls are now my go-to gift for those special people in my life.  Wash and block cowl to desired shape.
[caption id="attachment_1914" align="aligncenter" width="600"] Sweet Memories Cowl - By embracingitall[/caption]
[caption id="attachment_1915" align="aligncenter" width="504"] Sweet Memories Cowl - By embracingitall[/caption]
Feel free to leave a link to your finished project in the comments section. I'd love to see your version of the cowl. Happy knitting! Jacinta x


--- layout: documentation title: RoutesType ---
The RoutesType is intended to characterize a set network routes.
| Field Name | Type | Description |
|---|---|---|
| Route1..n | NetworkRouteEntryObjectType |
The Route field is intended to characterize a single network route. |


volatile
.
When using Java 1.4 or older, double-checked locking doesn't work even with a volatile
field.
Read the article linked above for an explanation of the problem.
Example of incorrect double checked locking:
class Foo {
private Helper helper = null;
public Helper getHelper() {
if (helper == null)
synchronized(this) {
if (helper == null) helper = new Helper();
}
return helper;
}
}
// other functions and members...
}


No clarity yet on new PCC chief
Leadership running out of time as civic polls are approaching
by G Venkataramana RaoThe Indian National Congress (INC) is still on the lookout for a person who can pull the party out of the dock in Andhra Pradesh.
The Congress, which was blamed for the bifurcation of the State, has witnessed two humiliating defeats in the elections conducted to the Legislative Assembly in Andhra Pradesh.
The party did not win even a single seat, and most of its candidates did not get back their deposits.
Party general secretary Oommen Chandy was in the city to consult leaders about who could lead them to fight against the YSRCP.
In the race
The names of former Chief Minister N. Kiran Kumar Reddy, six-time MP Chinta Mohan, former Union Minister M.M. Pallam Raju, former Minister S. Sailajanath, and active party leader Gidugu Rudraraju have been put before the leadership.
The candidates will be given points on the basis of their animosity to the ruling YSRCP and the Opposition TDP.
The leadership is giving highest points to these aspects in the light of allegations that some senior leaders of the party colluded with either the YSRCP or the TDP in the recent elections.
The leadership is also looking for a candidate who can take on the political and verbal onslaught of the ruling YSRCP, which has adopted “zero tolerance” towards the “mother Congress.”
“Soft-spoken and inexperienced leaders would get less marks, and the new chief will be selected mainly on the basis of these two criteria,” a senior party leader says.
With the civic elections fast approaching, the leadership does not have any time to drag its feet and will be forced to select one from the list.


A flexible and beautiful Select Input control for React with multiselect, autocomplete and ajax support.


HUI-MIN LU(Betty)
Home
Subscribe
My Favorite Cities
My Tasks
Working Experience
Contact Infomation
Education
Programming Languages