Today Kali 2020.2 has been released and with it lots of new visual changes and desktop improvements.
Here's a quick summary of what's new:
Following the previous release posts I published, here I want to show only the visual changes, but you can read more about all the improvements for Kali 2020.2 here:
During the last releases, Kali Linux has been announcing a whole set of new themes and features for its different desktops. At the end of last year, Kali 2019.4 announced the move to Xfce desktop, intending to provide better performance for small ARM devices that don't have as high performance as an average desktop. Later this year, Kali 2020.1 introduced the new themes for the GNOME desktop, aimed for all those people that missed the previous environment.
As many have been asking for, this time is the turn for KDE, one of the most popular desktops available for Linux. With this update, if you choose to install KDE, you'll be provided with the Plasma desktop, fully personalized with the new Kali designs and colors.
One nice feature about KDE is that it includes a 'Global Theme' menu, that allows you to change all the different themes at once. That way switching between the available light and dark skins is a straight forward process, so you don't have to configure the window, color-scheme, and plasma themes one by one.
In case you use Kali's default desktop, you'll notice some changes in the login screen (lightdm). Version 2019.4 already included a new theme for it, directly based on the application's one. Even so, this update introduces a new skin, redesigned with a modern look in both dark and light variants.
In order to make it easier to adjust the login screen to your liking, the greeter's settings program comes now preinstalled by default, where you can find the options to modify parameters like the theme, background image, font, user image, dialog position, and many others.
Like the previous update, this release adds many app icons, this time more focused on packages that don't come with the default Kali Linux installation. Now, even if you install the kali-linux-everything
package, there won't be an app out of the submenus without a new icon.
Note that the previous announcement already incorporated some of these icons, but they've been improved for this version.
Some applications using Kali's Qt theme weren't properly showing due to a misconfiguration of the color-scheme. One of the programs that clearly showed the issue was Virtualbox. This issue is now fixed for both dark and light themes.
Kali undercover has also seen some minor improvements. One of them is the integration with Plank panel, as the undercover mode will now hide it if it is running. Plank doesn't come preinstalled in Kali, but it is a widely used program on Xfce.
Xfce already provides support for HiDPI displays, but it works only for GTK apps. Kali Linux includes multiple tools, and each of them uses a different graphical library, such as GTK, Qt, java swing... Therefore, in order to set up all these applications to scale correctly, there is some tweaking you need to do.
While it still needs to be manually configured, this new release improves support for HiDPI, and in the future, it will provide automated support. Find all the documentation at:
Here is the general script to enable HiDPI 2x scale mode (Xfce only):
xfconf-query -c xfwm4 -p /general/theme -s Kali-Dark-xHiDPI xfconf-query -c xsettings -p /Gdk/WindowScalingFactor -n -t 'int' -s 2 cat <<- EOF >> ~/.xsessionrc export QT_SCALE_FACTOR=2 export XCURSOR_SIZE=48 export GDK_SCALE=2 EOF
Kali looks impressive out of the box, but even still, it is not for everyone, and, if you are like me, you feel the need to customize its appearance to your taste. For this reason, during the development of this new release, I wrote a post where I show you some of the tricks to customize the new Xfce desktop and help you make your computer look different / stand out.
kali-desktop-xfce
is installedHere you have it, all the new wallpapers uncompressed and in 4k resolution 😉
In case you want to install more wallpapers you can download all the legacy ones from the following package:
sudo apt install kali-legacy-wallpapers
Or from the community wallpapers repository:
sudo apt install kali-community-wallpapers


Here’re some upcoming events you might like to check out, if you see the balena logo next to an event that means we’ll be there - come and say hello!
{{ this.location }}
{{ this.date }}


Seasoned Dev
You will be redirected to a page in a moment.
If you are not redirected automatically,
click here
.


The menu Individual Procedures contains the following commands and sub menus:
| Hash | Calculate the hash value or the fingerprint for a document. |
| RSA Cryptosystem | Various tools and demonstrations around the RSA cryptosystem. |
| Protocols | Demonstrations of various protocols. |
| Chinese Remainder Theorem Applications | A practical demonstration of the Chinese Remainder Theorem. |
| Visualization of Algorithms | Visualization of various algorithms. |
| Secret Sharing Demonstration (Shamir) | Demonstration of the Secret Sharing procedure according to Shamir. |
| Tools | Various applications like the random generation, compression of data and password tests. |
| Educational Games | Hands-on learning of cryptography. |
| Number Theory - Interactive | Various interactive programs covering number theory and cryptography. |


BlueWallet supports various Bitcoin wallet implementations, BIPs and different integrations with external services. You can easily import any wallet with our wallet recovery and import feature.
Native Segwit addresses wallet are the latest in terms of technology that allow you to save up to 40% in fees.
The Watch-only wallet, as the name suggests is a wallet that allows you to keep an eye on your balance and receive transactions without touching your private key.
The Multisig Vault is a bitcoin wallet with multiple keys. It is advised for large amounts because it has the best security. It requires multiple keys to spend funds.
The Bitcoin Lightning wallet can be used on hosted fashion or self-hosted if you run your own node. This wallet provides the ability to receive lightning out of the box and send payments as well.
The wrapped segwit Bitcoin wallet is available in the advanced mode. It provides the best compatibility with exchanges and old services.
The Single address Bitcoin wallet, it's a Segwit compatible wallet that always will have the same receiving address. This is available in advanced mode.
Legacy wallet types start by 1... they are still widely use and you can import them through the import feature.
Electrum is a old Bitcoin wallet that has their own type that is not compatible with other apps. BlueWallet makes sure it can support it.
Bread wallet has a custom wallet format, usually not supported by other wallets. We made sure we have that available in case you want to import your bread wallet.
The create wallet options allows you to add wallet by simply choosing the type you want. The Bitcoin wallet (a multi address HD and segwit) is the default recommended one.
Bluewallet provides a “magic form” where you can try to import and recover whatever you got. It will do its best to understand the format and import your wallet into your BlueWallet app.


Boned is a boilerplate that can help you easily design websites that look beautiful at any size, be it a laptop screen, tablet or smartphone. It's based on a responsive grid, but also provides very basic CSS for typography, buttons, forms and media queries. Go ahead, resize this super basic page to see the grid in action.
Boned is built on three core principles:
The easiest way to really get started with Boned is to check out the full docs and info in the assets/doc/ directory. Boned is also open-source and has a project on git, so check that out if you want to report bugs or create a pull request.


The Dwarf Planet Project is a combined effort of software and space engineers to create open source tools valuable for research and space engineering. Currently we are able to showcase two top-level projects. One project focuses on the creation of an open source software tool for the design of Spacecrafts and Space Missions. The other aims for a simple deployable version of the server component of the Zotero Reference Management tool.
Project Manager
Software Developer
Quality Assurance
Particle Radiation module for the SDT project
Evaluation of Computational Platforms
GUI Designer for the SDT project


Digital branch temperature monitoring system
{% csrf_token %}
Q-Electronics
Area
Temp (C')
Humi (%)
Digital branch
Area 1
-
-
Area 2
-
-
Area 3
-
-


|
数字式立体视觉刺激系统
1.0.1
Digital Stereo System
|
#include <nvapi.h>
Public 属性 | |
| NvU32 | version |
| Structure version. 更多... | |
| NvU32 | flags |
| bit 0 indicates if the dynamic Pstate is enabled or not 更多... | |
| struct { | |
| NvU32 bIsPresent:1 | |
| Set if this utilization domain is present on this GPU. 更多... | |
| NvU32 percentage | |
| Percentage of time where the domain is considered busy in the last 1 second interval. 更多... | |
| } | utilization [NVAPI_MAX_GPU_UTILIZATIONS] |
Used in NvAPI_GPU_GetDynamicPstatesInfoEx().
| NvU32 NV_GPU_DYNAMIC_PSTATES_INFO_EX::bIsPresent |
Set if this utilization domain is present on this GPU.
| NvU32 NV_GPU_DYNAMIC_PSTATES_INFO_EX::flags |
bit 0 indicates if the dynamic Pstate is enabled or not
| NvU32 NV_GPU_DYNAMIC_PSTATES_INFO_EX::percentage |
Percentage of time where the domain is considered busy in the last 1 second interval.
| struct { ... } NV_GPU_DYNAMIC_PSTATES_INFO_EX::utilization[NVAPI_MAX_GPU_UTILIZATIONS] |
| NvU32 NV_GPU_DYNAMIC_PSTATES_INFO_EX::version |
Structure version.


Tracker
About
Home
Manage all of your payments in one location.
Create
a list of payments.
Assign
due dates.
See
when payments are overdue.
Sign Up
Already have an account? Log in


# Licensed under a 3-clause BSD style license - see LICENSE.rst
from __future__ import (absolute_import, division, print_function,
unicode_literals)
from .client import SAMPClient
from .hub_proxy import SAMPHubProxy
__all__ = ['SAMPIntegratedClient']
__doctest_skip__ = ['SAMPIntegratedClient.*']
[docs]class SAMPIntegratedClient(object):
"""
A Simple SAMP client.
This class is meant to simplify the client usage providing a proxy class
that merges the :class:`~astropy.vo.samp.SAMPClient` and
:class:`~astropy.vo.samp.SAMPHubProxy` functionalities in a
simplified API.
Parameters
----------
name : str, optional
Client name (corresponding to ``samp.name`` metadata keyword).
description : str, optional
Client description (corresponding to ``samp.description.text`` metadata
keyword).
metadata : dict, optional
Client application metadata in the standard SAMP format.
addr : str, optional
Listening address (or IP). This defaults to <IP_ADDRESS> if the internet
is not reachable, otherwise it defaults to the host name.
port : int, optional
Listening XML-RPC server socket port. If left set to 0 (the default),
the operating system will select a free port.
https : bool, optional
If `True`, set the callable client running on a Secure Sockets Layer
(SSL) connection (HTTPS). By default SSL is disabled.
key_file : str, optional
The path to a file containing the private key for SSL connections. If
the certificate file (``cert_file``) contains the private key, then
``key_file`` can be omitted.
cert_file : str, optional
The path to a file which contains a certificate to be used to identify
the local side of the secure connection.
cert_reqs : int, optional
Whether a certificate is required from the server side of the
connection, and whether it will be validated if provided. It must be
one of the three values `ssl.CERT_NONE` (certificates ignored),
`ssl.CERT_OPTIONAL` (not required, but validated if provided), or
`ssl.CERT_REQUIRED` (required and validated). If the value of this
parameter is not `ssl.CERT_NONE`, then the ``ca_certs`` parameter must
point to a file of CA certificates.
ca_certs : str, optional
The path to a file containing a set of concatenated "Certification
Authority" certificates, which are used to validate the certificate
passed from the Hub end of the connection.
ssl_version : int, optional
Which version of the SSL protocol to use. Typically, the
server chooses a particular protocol version, and the client
must adapt to the server's choice. Most of the versions are
not interoperable with the other versions. If not specified,
the default SSL version is taken from the default in the
installed version of the Python standard `ssl` library. See
the `ssl` documentation for more information.
callable : bool, optional
Whether the client can receive calls and notifications. If set to
`False`, then the client can send notifications and calls, but can not
receive any.
"""
def __init__(self, name=None, description=None, metadata=None,
addr=None, port=0, https=False, key_file=None, cert_file=None,
cert_reqs=0, ca_certs=None, ssl_version=None, callable=True):
self.hub = SAMPHubProxy()
self.client_arguments = {
'name': name,
'description': description,
'metadata': metadata,
'addr': addr,
'port': port,
'https': https,
'key_file': key_file,
'cert_file': cert_file,
'cert_reqs': cert_reqs,
'ca_certs': ca_certs,
'ssl_version': ssl_version,
'callable': callable,
}
"""
Collected arguments that should be passed on to the SAMPClient below.
The SAMPClient used to be instantiated in __init__; however, this
caused problems with disconnecting and reconnecting to the HUB.
The client_arguments is used to maintain backwards compatibility.
"""
self.client = None
"The client will be instantiated upon connect()."
# GENERAL
@property
def is_connected(self):
"""
Testing method to verify the client connection with a running Hub.
Returns
-------
is_connected : bool
True if the client is connected to a Hub, False otherwise.
"""
return self.hub.is_connected and self.client.is_running
[docs] def connect(self, hub=None, hub_params=None,
key_file=None, cert_file=None, cert_reqs=0,
ca_certs=None, ssl_version=None, pool_size=20):
"""
Connect with the current or specified SAMP Hub, start and register the
client.
Parameters
----------
hub : `~astropy.vo.samp.SAMPHubServer`, optional
The hub to connect to.
hub_params : dict, optional
Optional dictionary containing the lock-file content of the Hub
with which to connect. This dictionary has the form
``{<token-name>: <token-string>, ...}``.
key_file : str, optional
The path to a file containing the private key for SSL connections.
If the certificate file (``cert_file``) contains the private key,
then ``key_file`` can be omitted.
cert_file : str, optional
The path to a file which contains a certificate to be used to
identify the local side of the secure connection.
cert_reqs : int, optional
Whether a certificate is required from the server side of the
connection, and whether it will be validated if provided. It must
be one of the three values `ssl.CERT_NONE` (certificates ignored),
`ssl.CERT_OPTIONAL` (not required, but validated if provided), or
`ssl.CERT_REQUIRED` (required and validated). If the value of this
parameter is not `ssl.CERT_NONE`, then the ``ca_certs`` parameter
must point to a file of CA certificates.
ca_certs : str, optional
The path to a file containing a set of concatenated "Certification
Authority" certificates, which are used to validate the
certificate passed from the Hub end of the connection.
ssl_version : int, optional
Which version of the SSL protocol to use. Typically, the
server chooses a particular protocol version, and the
client must adapt to the server's choice. Most of the
versions are not interoperable with the other versions. If
not specified, the default SSL version is taken from the
default in the installed version of the Python standard
`ssl` library. See the `ssl` documentation for more
information.
pool_size : int, optional
The number of socket connections opened to communicate with the
Hub.
"""
self.hub.connect(hub, hub_params, key_file, cert_file,
cert_reqs, ca_certs, ssl_version, pool_size)
# The client has to be instantiated here and not in __init__() because
# this allows disconnecting and reconnecting to the HUB. Nonetheless,
# the client_arguments are set in __init__() because the
# instantiation of the client used to happen there and this retains
# backwards compatibility.
self.client = SAMPClient(
self.hub,
**self.client_arguments
)
self.client.start()
self.client.register()
[docs] def disconnect(self):
"""
Unregister the client from the current SAMP Hub, stop the client and
disconnect from the Hub.
"""
if self.is_connected:
try:
self.client.unregister()
finally:
if self.client.is_running:
self.client.stop()
self.hub.disconnect()
# HUB
[docs] def ping(self):
"""
Proxy to ``ping`` SAMP Hub method (Standard Profile only).
"""
return self.hub.ping()
[docs] def get_subscriptions(self, client_id):
"""
Proxy to ``getSubscriptions`` SAMP Hub method.
"""
return self.hub.get_subscriptions(self.get_private_key(), client_id)
[docs] def get_registered_clients(self):
"""
Proxy to ``getRegisteredClients`` SAMP Hub method.
This returns all the registered clients, excluding the current client.
"""
return self.hub.get_registered_clients(self.get_private_key())
[docs] def get_subscribed_clients(self, mtype):
"""
Proxy to ``getSubscribedClients`` SAMP Hub method.
"""
return self.hub.get_subscribed_clients(self.get_private_key(), mtype)
def _format_easy_msg(self, mtype, params):
msg = {}
if "extra_kws" in params:
extra = params["extra_kws"]
del(params["extra_kws"])
msg = {"samp.mtype": mtype, "samp.params": params}
msg.update(extra)
else:
msg = {"samp.mtype": mtype, "samp.params": params}
return msg
[docs] def notify(self, recipient_id, message):
"""
Proxy to ``notify`` SAMP Hub method.
"""
return self.hub.notify(self.get_private_key(), recipient_id, message)
[docs] def enotify(self, recipient_id, mtype, **params):
"""
Easy to use version of :meth:`~astropy.vo.samp.integrated_client.SAMPIntegratedClient.notify`.
This is a proxy to ``notify`` method that allows to send the
notification message in a simplified way.
Note that reserved ``extra_kws`` keyword is a dictionary with the
special meaning of being used to add extra keywords, in addition to
the standard ``samp.mtype`` and ``samp.params``, to the message sent.
Parameters
----------
recipient_id : str
Recipient ID
mtype : str
the MType to be notified
params : dict or set of keywords
Variable keyword set which contains the list of parameters for the
specified MType.
Examples
--------
>>> from astropy.vo.samp import SAMPIntegratedClient
>>> cli = SAMPIntegratedClient()
>>> ...
>>> cli.enotify("samp.msg.progress", msgid = "xyz", txt = "initialization",
... percent = "10", extra_kws = {"my.extra.info": "just an example"})
"""
return self.notify(recipient_id, self._format_easy_msg(mtype, params))
[docs] def notify_all(self, message):
"""
Proxy to ``notifyAll`` SAMP Hub method.
"""
return self.hub.notify_all(self.get_private_key(), message)
[docs] def enotify_all(self, mtype, **params):
"""
Easy to use version of :meth:`~astropy.vo.samp.integrated_client.SAMPIntegratedClient.notify_all`.
This is a proxy to ``notifyAll`` method that allows to send the
notification message in a simplified way.
Note that reserved ``extra_kws`` keyword is a dictionary with the
special meaning of being used to add extra keywords, in addition to
the standard ``samp.mtype`` and ``samp.params``, to the message sent.
Parameters
----------
mtype : str
MType to be notified.
params : dict or set of keywords
Variable keyword set which contains the list of parameters for
the specified MType.
Examples
--------
>>> from astropy.vo.samp import SAMPIntegratedClient
>>> cli = SAMPIntegratedClient()
>>> ...
>>> cli.enotify_all("samp.msg.progress", txt = "initialization",
... percent = "10",
... extra_kws = {"my.extra.info": "just an example"})
"""
return self.notify_all(self._format_easy_msg(mtype, params))
[docs] def call(self, recipient_id, msg_tag, message):
"""
Proxy to ``call`` SAMP Hub method.
"""
return self.hub.call(self.get_private_key(), recipient_id, msg_tag, message)
[docs] def ecall(self, recipient_id, msg_tag, mtype, **params):
"""
Easy to use version of :meth:`~astropy.vo.samp.integrated_client.SAMPIntegratedClient.call`.
This is a proxy to ``call`` method that allows to send a call message
in a simplified way.
Note that reserved ``extra_kws`` keyword is a dictionary with the
special meaning of being used to add extra keywords, in addition to
the standard ``samp.mtype`` and ``samp.params``, to the message sent.
Parameters
----------
recipient_id : str
Recipient ID
msg_tag : str
Message tag to use
mtype : str
MType to be sent
params : dict of set of keywords
Variable keyword set which contains the list of parameters for
the specified MType.
Examples
--------
>>> from astropy.vo.samp import SAMPIntegratedClient
>>> cli = SAMPIntegratedClient()
>>> ...
>>> msgid = cli.ecall("abc", "xyz", "samp.msg.progress",
... txt = "initialization", percent = "10",
... extra_kws = {"my.extra.info": "just an example"})
"""
return self.call(recipient_id, msg_tag, self._format_easy_msg(mtype, params))
[docs] def call_all(self, msg_tag, message):
"""
Proxy to ``callAll`` SAMP Hub method.
"""
return self.hub.call_all(self.get_private_key(), msg_tag, message)
[docs] def ecall_all(self, msg_tag, mtype, **params):
"""
Easy to use version of :meth:`~astropy.vo.samp.integrated_client.SAMPIntegratedClient.call_all`.
This is a proxy to ``callAll`` method that allows to send the call
message in a simplified way.
Note that reserved ``extra_kws`` keyword is a dictionary with the
special meaning of being used to add extra keywords, in addition to
the standard ``samp.mtype`` and ``samp.params``, to the message sent.
Parameters
----------
msg_tag : str
Message tag to use
mtype : str
MType to be sent
params : dict of set of keywords
Variable keyword set which contains the list of parameters for
the specified MType.
Examples
--------
>>> from astropy.vo.samp import SAMPIntegratedClient
>>> cli = SAMPIntegratedClient()
>>> ...
>>> msgid = cli.ecall_all("xyz", "samp.msg.progress",
... txt = "initialization", percent = "10",
... extra_kws = {"my.extra.info": "just an example"})
"""
self.call_all(msg_tag, self._format_easy_msg(mtype, params))
[docs] def call_and_wait(self, recipient_id, message, timeout):
"""
Proxy to ``callAndWait`` SAMP Hub method.
"""
return self.hub.call_and_wait(self.get_private_key(), recipient_id, message, timeout)
[docs] def ecall_and_wait(self, recipient_id, mtype, timeout, **params):
"""
Easy to use version of :meth:`~astropy.vo.samp.integrated_client.SAMPIntegratedClient.call_and_wait`.
This is a proxy to ``callAndWait`` method that allows to send the call
message in a simplified way.
Note that reserved ``extra_kws`` keyword is a dictionary with the
special meaning of being used to add extra keywords, in addition to
the standard ``samp.mtype`` and ``samp.params``, to the message sent.
Parameters
----------
recipient_id : str
Recipient ID
mtype : str
MType to be sent
timeout : str
Call timeout in seconds
params : dict of set of keywords
Variable keyword set which contains the list of parameters for
the specified MType.
Examples
--------
>>> from astropy.vo.samp import SAMPIntegratedClient
>>> cli = SAMPIntegratedClient()
>>> ...
>>> cli.ecall_and_wait("xyz", "samp.msg.progress", "5",
... txt = "initialization", percent = "10",
... extra_kws = {"my.extra.info": "just an example"})
"""
return self.call_and_wait(recipient_id, self._format_easy_msg(mtype, params), timeout)
[docs] def reply(self, msg_id, response):
"""
Proxy to ``reply`` SAMP Hub method.
"""
return self.hub.reply(self.get_private_key(), msg_id, response)
def _format_easy_response(self, status, result, error):
msg = {"samp.status": status}
if result is not None:
msg.update({"samp.result": result})
if error is not None:
msg.update({"samp.error": error})
return msg
[docs] def ereply(self, msg_id, status, result=None, error=None):
"""
Easy to use version of :meth:`~astropy.vo.samp.integrated_client.SAMPIntegratedClient.reply`.
This is a proxy to ``reply`` method that allows to send a reply
message in a simplified way.
Parameters
----------
msg_id : str
Message ID to which reply.
status : str
Content of the ``samp.status`` response keyword.
result : dict
Content of the ``samp.result`` response keyword.
error : dict
Content of the ``samp.error`` response keyword.
Examples
--------
>>> from astropy.vo.samp import SAMPIntegratedClient, SAMP_STATUS_ERROR
>>> cli = SAMPIntegratedClient()
>>> ...
>>> cli.ereply("abd", SAMP_STATUS_ERROR, result={},
... error={"samp.errortxt": "Test error message"})
"""
return self.reply(msg_id, self._format_easy_response(status, result, error))
# CLIENT
[docs] def receive_notification(self, private_key, sender_id, message):
return self.client.receive_notification(private_key, sender_id, message)
receive_notification.__doc__ = SAMPClient.receive_notification.__doc__
[docs] def receive_call(self, private_key, sender_id, msg_id, message):
return self.client.receive_call(private_key, sender_id, msg_id, message)
receive_call.__doc__ = SAMPClient.receive_call.__doc__
[docs] def receive_response(self, private_key, responder_id, msg_tag, response):
return self.client.receive_response(private_key, responder_id, msg_tag, response)
receive_response.__doc__ = SAMPClient.receive_response.__doc__
[docs] def bind_receive_message(self, mtype, function, declare=True, metadata=None):
self.client.bind_receive_message(mtype, function, declare=True, metadata=None)
bind_receive_message.__doc__ = SAMPClient.bind_receive_message.__doc__
[docs] def bind_receive_notification(self, mtype, function, declare=True, metadata=None):
self.client.bind_receive_notification(mtype, function, declare, metadata)
bind_receive_notification.__doc__ = SAMPClient.bind_receive_notification.__doc__
[docs] def bind_receive_call(self, mtype, function, declare=True, metadata=None):
self.client.bind_receive_call(mtype, function, declare, metadata)
bind_receive_call.__doc__ = SAMPClient.bind_receive_call.__doc__
[docs] def bind_receive_response(self, msg_tag, function):
self.client.bind_receive_response(msg_tag, function)
bind_receive_response.__doc__ = SAMPClient.bind_receive_response.__doc__
[docs] def unbind_receive_notification(self, mtype, declare=True):
self.client.unbind_receive_notification(mtype, declare)
unbind_receive_notification.__doc__ = SAMPClient.unbind_receive_notification.__doc__
[docs] def unbind_receive_call(self, mtype, declare=True):
self.client.unbind_receive_call(mtype, declare)
unbind_receive_call.__doc__ = SAMPClient.unbind_receive_call.__doc__
[docs] def unbind_receive_response(self, msg_tag):
self.client.unbind_receive_response(msg_tag)
unbind_receive_response.__doc__ = SAMPClient.unbind_receive_response.__doc__
[docs] def declare_subscriptions(self, subscriptions=None):
self.client.declare_subscriptions(subscriptions)
declare_subscriptions.__doc__ = SAMPClient.declare_subscriptions.__doc__
[docs] def get_private_key(self):
return self.client.get_private_key()
get_private_key.__doc__ = SAMPClient.get_private_key.__doc__
[docs] def get_public_id(self):
return self.client.get_public_id()
get_public_id.__doc__ = SAMPClient.get_public_id.__doc__


Bootstrap 5 Into Tour free extension
Plain JS extension for Bootstrap 5, which allows to create into/tours easly.
Bootsrap 5 Intro Tour is a extension for bootstrap 5. Moreover this plugin is very lightweight, because it written in plain JS, and don't have jquery dependencies.
If you find any bug or have ideas how can I improve this plugin, please create issue on github.
The extension is free, but any financial support is appreciated.


opentype.js
Font Inspector
Glyph Inspector
Fork me on GitHub
Glyph Inspector
opentype.js is an OpenType and TrueType font parser. Here you can inspect the raw glyph data.
Glyphs
Free Software
opentype.js is available on
GitHub
under the
MIT License
.
Copyright © 2020 Frederik De Bleser.


Programming Model
The MapReduce model is a specialisation of the split-apply-combine strategy for data analysis (Wickam, 2011). The
name draws its inspiration from the map and reduce functions commonly used in functional
programming language like Lisp.
The computation takes a set of input key/value pairs of data with a type in one data domain and
produces a set of output key/values pairs in a different domain. The user of the MapReduce library
has to define the two functions at the core of its computation: Map and Reduce (Jeffrey Dean, Sanjay Ghemawat, 2004).
- Map takes an input pair and produces a set of intermediate key/values pairs. The
MapReduce library groups together all intermediate values associated with the same
intermediate key I and passes them to the Reduce function.
- The Reduce function accepts an intermediate key I and a set of values for that key. It
merges together these values to form a possibly smaller set. Tipically just zero or one
output value is produced from one Reduce invocation.
The main advantage of this model is that it allows large computations to be easily parallelised and
re-executed to be used as the primary mechanism for fault tolerance.
Example (WordCount)
Figure 1 illustrates an example MapReduce program expressed in pseudo-code for counting the
number of occurences of each word in a collection of documents (Aris Gkoulalas, 2014).
Figure 1 - MapReduce WordCount pseudo-code example
In this example, the map function emits each word plus an associated mark of occurences, while
the reduce function sums together all marks emitted for a particular word.
Implementation
Many different implementation of the MapReduce interface are possible, each one tailored for a
specific problem. In principle, the design of the MapReduce library considers the following main
principles (Aris Gkoulalas, 2014):
- Low-Cost Unreliable Commodity Hardware: Instead of using expensive, high-performance,
reliable symmetric multiprocessing (SMP) or massively parallel processing (MPP) machines
equipped with high-end network and storage subsystems, the MapReduce framework is
designed to run on large clusters of commodity hardware. This hardware is managed and
powered by open-source operating systems and utilities so that the cost is kept low.
- Extremely Scalable RAIN Cluster: Instead of using centralized RAID-based SAN or NAS
storage systems, every MapReduce node has its own local off-theshelf hard drives. These
nodes are loosely coupled in rackable systems that are connected with generic LAN
switches. These nodes can be taken out of service with almost no impact to still-running
MapReduce jobs. These clusters are called Redundant Array of Independent (and
Inexpensive) Nodes (RAIN).
- Fault-Tolerant yet Easy to Administer: MapReduce jobs can run on clusters with thousands
of nodes or even more. These nodes are not very reliable as at any point in time, a certain
percentage of these commodity nodes or hard drives will be out of order. Hence, the
MapReduce framework applies straightforward mechanisms to replicate data and launch
backup tasks so as to keep still-running processes going. To handle crashed nodes, system
administrators simply take crashed hardware off-line. New nodes can be plugged in at any
time without much administrative hassle. There is no complicated backup, restore and
recovery configurations like the ones that can be seen in many DBMS.
- Highly Parallel yet Abstracted: The most important contribution of the MapReduce
framework is its ability to automatically support the parallelization of task executions.
Hence, it allows developers to focus mainly on the problem at hand rather than worrying
about the low level implementation details, such as memory management, file allocation,
parallel, multi-threaded or network programming. Moreover, MapReduce’s shared-nothing
architecture [38] makes it much more scalable and ready for parallelization.
For the sake of argument, we will describe an implementation targeted to the computing
enviroment used at Google: large clusters of commodity PCs connected together with switched Ethernet (Jeffrey Dean, Sanjay Ghemawat, 2004):
- Machines are typically dual-processor x86 processors running Linux, with 2-4 GB of
memory per machine.
- Commodity networking hardware is used – typically either 100 megabits/second or 1
gigabit/second at the machine level, but averaging considerably less in overall bisection
bandwidth.
- A cluster consists of hundreds or thousands of machines, and therefore machine failures
are common.
Ethernet:
- Storage is provided by inexpensive IDE disks attached directly to individual machines. A
distributed file system [8] developed in-house is used to manage the data stored on these
disks. The file system uses replication to provide availability and reliability on top of
unreliable hardware.
- Users submit jobs to a scheduling system. Each job consists of a set of tasks, and is mapped
by the scheduler to a set of available machines within a cluster.
Execution Overview
The MapReduce computations are compositions of two phases (Dimitrov, 2016):
MapPhase: list(k1, v1) -> list(k2, v2)
The framework accepts a list of key / value pairs on input. For each pair, it calls a map that
generates a list of intermediate key / value pair.
The ReductionPhase is subdivided in two subphases:
preparation: list(k2, v2) -> list(k2, list(v2))
In the preparation phase, the framework sorts the lists produced during the previous phase, and the
result is a list of intermediate keys / list of values. In this list, each key is associated with all the
values generated for it.
reduction: list(k2, list(v2)) -> list(k2, v2)
After that, the reduce phase. For every pair in the list, the framework calls the function reduce,
which produces a list of values for the key.
In the Google implementation, the Map calls are distributed across multiple machines by
automatically partitioning the input data into a set of M splits. The input splits can be processed in
parallel by different machines. Reduce invocations are distributed by partitioning the intermediate
key space into R pieces using a partitioning function, usually a hash function (e.g. hash(key) mod
R). However, the number of partitions (R) and the partitioning function are specified by the user.
When the user program invokes the MapReduce function, the following sequence of actions is
executed (Jeffrey Dean, Sanjay Ghemawat, 2004):
- The MapReduce library in the user program first splits the input files into M pieces of
typically 16 megabytes to 64 megabytes (MB) per piece (controllable by the user via an
optional parameter). It then starts up many copies of the program on a cluster of machines
- One of the copies of the program is special: the master. The rest are workers that are
assigned work by the master. There are M map tasks and R reduce tasks to assign. The
master picks idle workers and assigns each one a map task or a reduce task.
- A worker who is assigned a map task reads the contents of the corresponding input split. It
parses key/value pairs out of the input data and passes each pair to the user-defined Map
function. The intermediate key/value pairs produced by the Map function are buffered in
memory.
- Periodically, the buffered pairs are written to local disk, partitioned into R regions by the
partitioning function. The locations of these buffered pairs on the local disk are passed
back to the master, who is responsible for forwarding these locations to the reduce
workers.
- When a reduce worker is notified by the master about these locations, it uses remote
procedure calls to read the buffered data from the local disks of the map workers. When a
reduce worker has read all intermediate data, it sorts it by the intermediate keys so that all
occurrences of the same key are grouped together. The sorting is needed because typically
many different keys map to the same reduce task. If the amount of intermediate data is
too large to fit in memory, an external sort is used.
- The reduce worker iterates over the sorted intermediate data and for each unique
intermediate key encountered, it passes the key and the corresponding set of intermediate
values to the user’s Reduce function. The output of the Reduce function is appended to a
final output file for this reduce partition.
- When all map tasks and reduce tasks have been completed, the master wakes up the user
program. At this point, the MapReduce call in the user program returns back to the user
code.
Figure 2 show the execution of a MapReduce operation in our implementation (Jeffrey Dean, Sanjay Ghemawat, 2004).
Figure 2 - MapReduce Execution
When the algorithm terminates, the output of the MapReduce execution is available in the R
output files (one per each reduce task, with file names specified by the user). Typically, users do
not merge these R output files as they are usually passed to another MapReduce call or used by
another distributed application which is able to process input that is partitioned into multiple files.
Figure 3 illustrates the execution of the wordcount example using MapReduce (Aris Gkoulalas, 2014).
Figure 3 - MapReduce WordCount Execution Example
Advantages
Easy to use
One of the main advantages of the MapReduce model is that it can be easily used by programmers
who have no experience with parallel and distributed systems (Jeffrey Dean, Sanjay Ghemawat, 2004). Also, the key contributions of the
MapReduce framework are not the actual map and reduce functions, but the scalability and fault-tolerance
achieved for a variaty of applications by optimising the execution engine. As a
consequence, relative improvement can only be seen with multi-threaded implementations.
Fault-tolerance and Determinism
Since it was programmed to tackle massive amounts of data, the MapReduce model must tolerate
machine failures peacefully (Jeffrey Dean, Sanjay Ghemawat, 2004). The master is responsible for scheduling the tasks and tackle workers
failures. For each map task and reduce task, it stores the state (idle, in-progress, or completed),
and the identity of the worker machine (for non-idle tasks). For each completed map task, the
master stores the locations and sizes of the R intermediate file regions produce by the map.
MapReduce is resilient to large-scale worker failure. The master pings every worker periodically
and if it does not respond after a reasonable amount of time it is marked as failed. Any map tasks
completed by a failed worker are simply re-executed in order to make progress. If the master fails,
the job must be re-executed from scratch.
Another important aspect of the MapReduce model is ist determinism (Dimitrov, 2016). Since map and reduce
function may be deterministic regarding their inputs, the framework guarantees that the program
will generate the same output each time. Furthermore, when user-defined functions are
nondeterministic, the framework assures that for each distributed execution, there exist at least
one sequential execution that can produce the same output.
Locality and Backup Tasks
Since network bandwidth is a relatively scarce resource in a distributed system the MapReduce
model takes advantage of the fact that the input data is stored on the local disks of the machines
that make up the cluster (Jeffrey Dean, Sanjay Ghemawat, 2004). The MapReduce master takes the location information of the input files
into account and attempts to schedule a map task on a machine that contains a replica of that
input’s task data, or near a replica of that task’s input data. This way, most input data is read
locally and consumes no network bandwidth. Furthermore, when a MapReduce operation is close
to completion, the master schedules backup executions of the remaining in-progress tasks. The
task is marked as completed whenever either the primary or the backup execution completes, so
that if a machine takes an unusual time to complete a task, it does not slow down the entire
process.
Disadvantages
One of the main disadvanteges of the MapReduce model is not being suitable for real time
processing. MapReduce is a useful tool for batch processing, a process in which data is first
collected over a period of time, then processed by a separated program and finally is retrieved.
However, these steps usually require a reasonable amount of time, which is a tradeoff to their
powerful performances. For this very reason, it is clear that a MapReduce solution would not be
feasible to get data processed and retrieved in real time. Furthermore, every map task performed
by each worker must be independent from the other, that is there must be no dependency
between intermediate processes (job isolation).
Refinements and Variations
Although the basic functionality provided by MapReduce is sufficient for most needs, there are a
few extension which could be useful (Jeffrey Dean, Sanjay Ghemawat, 2004):
Partitioning Function
Despite data being partitioned across the tasks using a default partitioning function (usually a
hashing function) this variation allows the user to define a custom partitioning function, as well as
map and reduce functions, to split data according to specific needs. For example, sometimes the
output keys are URLs, and we want all entries for a single host to end up in the same output file.
Combiner Function
In some cases, there is significant repetition in the intermediate keys produced by each map task
(like in the wordcount example). An interesting variation is used to allow the user to specify an
optional Combiner function that does partial merging of this data before it is sent over the
network. Typically the same code is used to implement both the combiner and the reduce
functions. Furthermore, it significantly speeds up certain classes of MapReduce operations.
Map-Reduce-Merge
One of the main limitation of the MapReduce framework is that it does not provide any method to
join multiple datasets in one task. However, this could still be achieved by introducing an
additional MapReduce step. In this new model, the map function transforms an input key/value
pair (k1, v1) into a list of intermediate key/value pairs [(k2, v2)] (Hung-chih Yang, Ali Dasdan, Ruey-Lung Hsiao, D. Stott Parker, 2007). The reduce function aggregates
the list of values [v2] associated with k2 and produces a list of values [v3], which is also associated
with k2. Note that inputs and outputs of both functions belong to the same lineage, say α. Another
pair of map and reduce functions produce the intermediate output (k3, [v4]) from another lineage,
say β. Based on keys k2 and k3, the merge function combines the two reduced outputs from
different lineages into a list of key/value outputs [(k4, v5)]. This final output becomes a new
lineage, say γ. If α = β, then this merge function does a self-merge, similar to self-join in relational
algebra. This could be useful for relational data processing on large clusters.
Real-World Examples
Despite being created by Google, the MapReduce model has been adopted by many other
companies. Nowadays, it has been used across a wide range of domains such as (P. Sudha, Dr. R. Gunavathi, 2016):
- Large-scale machine learning problems
- clustering problems for the Google News and Froogle products
- extracting data to produce reports of popular queries(e.g. Google Zeitgeist and Google
Trends)
- extracting properties of web pages for new experiments and products (e.g. extraction of
geographical locations from a large corpus of Web Pages for localized search)
- processing of satellite imagery data
- Language model processing for statistical machine Translation
- Large-scale graph computations
One of the most widespread and used implementation is Apache Hadoop.
Further information regarding practical examples can be found here.
References
Wickham, Hadley (2011). "The split-apply-combine strategy for data analysis". Journal of Statistical Software
MapReduce: Simplified Data Processing on Large Clusters, by Jeffrey Dean and Sanjay Ghemawat; from Google
Research
Aris Gkoulalas-Divanis, Large-Scale Data Analytics, Abderrahim Labbi Editors
The Performance of MapReduce: An In-depth Study, Dawei Jiang, Beng Chin Ooi, Lei Shi, Sai Wu, School of
Computing National University of Singapore
Encyclopedia of Cloud Computing, Vladimir Dimitrov, University of Sofia, Bulgaria
A Survey Paper on Map Reduce in Big Data, P. Sudha, Dr. R. Gunavathi, Sree Saraswathi Thyagaraja College
Map-Reduce-Merge: Simplified Relational Data Processing on Large Clusters, Hung-chih Yang, Ali Dasdan,
Yahoo!, Ruey-Lung Hsiao, D. Stott Parker, Computer Science Department, UCLA


Anatomy of an Actor
class MyActor extends Actor {
def receive = {
case s: String => println(s"received string: $s")
}
}
Tell
val myActor = system.actorOf(Props(new MyActor(constructorParam)))
myActor ! "test" // Send string
Ask
val person: Future[Person] = (myActor ? "select * from person;").mapTo[Person]
Router Config
val router = context.actorOf(FromConfig.props(Props[Worker]), "router1")
akka.actor.deployment {
/parent/router1 {
router = round-robin-pool
resizer {
lower-bound = 2
upper-bound = 15
messages-per-resize = 100
}
}
}
Parents supervise their children
Underlying thread pools
Configurable at runtime
Movio Email Delivery


Academic
His GPA ranked No.1 in each semester during his undergraduate studies
with overall GPA: 3.96/4.00 and Rank: 1/183.
He finished major curricula in 2 years and learned a bunch of online courses.
[Whole]
Course Projects
Computer Vision
3D Human Poses Estimation from a Single Image
[Presentation]
Used sparse coding to reduce the ambiguities in the 3D pose estimation;
Enforced human-portion constraints to get a minimization problem
Convex Optimization
Road Car Flow and Its Effect on Roads
[Paper]
Constructed models to depict road circumstances and to predict car motion using
Markov Decision Process and OD estimated matrix; Improved the models in terms of traffic load and vehicle type.
Probability and Stochastic Process
Monte Carlo Method for Multidimensional Integrals
[Report]
Machine Learning
Construction of a Spam Filtering System
Microcomputers and Interface Techniques
x86 Assembly Language Programming
[Report]
Signal Processing Single Photon Detector
[Paper]
[Presentation]
Designed a 64-channel low-noise pre-amplifier using a symmetric structure, reduced noise by 100 times, drew an 8-layers circuit board.
Leadership Experience
Co-Founder of a Children Care Volunteer Program
Sep.2015-Dec.2015
Co-founded a psychological consulting program to promote left-behind children growth and education.
Volunteered to teach left-behind children Math and English in
a junior high school located in the remote, underdeveloped Xiushui county.
Recognized as a key team leader in the successful Warm One Hundred Campaign, which raised money for
left-behind children. Our group received excellence award from China Foundation for Poverty Alleviation.
Vice President of a Young Volunteers Association at Nanjing University
    Jun.2015-Jun.2016
Organized and participated in over 100 out-of-school and 20 in-school activities covering over 1000 volunteers.
Our association received a volunteers association excellence award.
Awards
| Hong Kong PhD Fellowship |
2018 |
| National Scholarship awarded by the China Ministry of Education, the highest honor in China | 2015 |
| Provincial-Level Merit Student awarded by the Jiangsu Provincial Government, the highest honor in Jiangsu Province | 2017 |
| Nanjing University Top-Grade Scholarship,
awarded to 12 students out of all undergraduate students at the university,
the highest honor in the university | 2018 |
| SenseTime Scholarship, awarded to 30 students out of all AI major undergraduate students in China | 2017 |
| Zhenggang Scholarship, top 40 students in Nanjing University | 2016 |
| Zhenggang Jingying Scholarship | 2017 |
| Nanjing University People Scholarship | 2016, 2017 |
| Nanjing University Outstanding Student Leader Award | 2015 |
| Nanjing University Outstanding Student Award | 2016 |
| Nanjing University Top Volunteer Excellence Award | 2015 |
| World ranking 32nd in 2016 Calculus World Cup | 2016 |
| Meritorious winner prize in the 2016 National Mathematical Contest in Modeling | 2016 |
| Best paper in the 2014 University Electronics Design Contest | 2014 |
| Gold Medal in Invitational National Mathematical Olympiad | 2013 |
Miscellaneous
Research intern group leader in CHANGJIANG ELEC. TECH.
[Media Report]
Member of Nanjing University Student Choir
(Joyful Snowflakes written by Chih-mo Hsu)
Vice president of a Young Volunteers Association
[Media Report]
Bronze medal at Nanjing University 55th Sports Meet
[Media Report]
Language: A bit of Japanese and Cantonese, Native Mandarin, Full proficiency English


--- title: calcTraces sidebar: function_reference_sidebar permalink: EBSD.calcTraces.html folder: function_reference toc: false ---
traces of subregions of an EBSD map
| ebsd | EBSD |
| clusterId | an id indicating for which pixel form a region |
| traces | vector3d size max(clusterId(:,1)) x max(clusterId(:,2)) .... |
| rel | relyability index |
| cSize | cluster size |
| minClusterSize | minimum number of pixels required for trace computation (default: 100) |
| Radon | Radon based algorithm |
| Fourier | Fourier based algorithm |


Hong Kong Code Conference will be held on Saturday 15th October 2016. It's a programming conference aimed at all programmers in Hong Kong. We want to share our skills and opinions. We want to inspire each other with our passion. We want to build a closer, stronger community.
we ❤ hk coders
I'm a British software engineer living in Hong Kong since 2010. My main interests are modern cloud infrastructure, programming languages and developer productivity tools. Outside computing, I like chess, Chinese language, philosophy, maths and music.
Andy Li is a member of the Haxe Foundation. He obtained his PhD in the School of Creative Media, City University of Hong Kong. He is interested in programming language theories as well as mobile user interface, interactivity, installation art and generative graphics.
Founder of Puppet Brazil community, Carla Souza currently works for Facebook as a Production Engineer. She has Bachelor in Computer Science, 10+ years of experience in Unix systems administration and Software development.
Github: @carlasouza
Twitter: @carlaas
Full-Stack developer. Founder and manager of MeteorSpark, a Hong Kong based Meteor consultancy.
Github: @theosp
Twitter: @daniel_chcouri
Emmanuel arrived in Hong Kong in 2010, as a researcher in Natural Language Processing for HKUST. He veered path toward Software Engineer and accidentally became a Data Scientist by combining both experiences (with a pinch of product management). Today, Emmanuel is a freelance data scientist.
Github: @eprochasson
Twitter: @eprochasson
Guy got a PhD in Statistics in England in 2011, after which he moved to Hong Kong and subsequently practised the dark arts of statistical modelling as a university epidemiologist, as an "Analytical Engineer" at a scrappy data science startup, as an Excel monkey at a Big Four consulting firm, and latterly as a "Big Data Manager" at an insurance company. He's pretty obsessed with open data, starting accessinfo.hk, a clone of the UK's Freedom of Information website whatdotheyknow.com, and his next "job" will be to open up Hong Kong's data once and for all. He is also technically one of the founders of the Hong Kong R User Group, and has used the venerable statistical programming language almost every day for over 10 years, but he always wonders what could have been with XLispStat...
Github: @slygent
Lio is an engineer and community organizer with Electrical Engineering and Computer Science background and 20 years of international industry experience doing software and hardware. A VR pioneer, he built and sold VR solutions from his first startup in 1997. In 2001 his company was acquired by a multinational company for his real-time 3D stereo rendering technology. Having worked on a wide range of projects, in startups and multinationals, Lio has accrued broad expertise in areas such as virtual reality, e-commerce, cloud computing, blockchain, and IoT.
Github: @lionello
Twitter: @lionellolunesu
Been coding way too long... From Solaris and UnixWare to Android and PalmOS, with a lot of Linux and a fair amount of web stuff in the meantime.
Twitter: @vmlinuz
Hacker working in financial services, currently developing trading platforms I'm Scala and Akka.
Hong Kong Native. Y Combinator and Apple alumni. Advisors to several HK and SF startups. Currently doing growth in Hong Kong for Stripe.
Github: @tpun
Twitter: @thomaspun
| Registration & Welcome | |
| 09:30 | Registration |
| 10:00 | Welcome |
| Session 1 | |
| 10:15 |
Andrew Medworth
- "In Defence of Boilerplate Code"
DescriptionMany languages, libraries and frameworks boast of their ability to eliminate boilerplate code. But does boilerplate code always deserve to die? This talk will argue that sometimes the cure is worse than the disease. It will draw examples primarily from the Java ecosystem, but will aim to offer techniques for designing and selecting abstractions which will be useful to all software engineers. |
| 10:45 |
Lionello Lunesu
- "Static code analysis in D"
DescriptionD's compiler already has some advanced code analysis tools. For example, it currently uses Value Range Propagation (VRP) for implicit casting between integers of different sizes, but that's only one of the many things VRP is useful for. VRP can be extended to include code optimization, branch prediction, static code analysis, and proof code correctness. |
| 11:15 |
Richard Cohen
- "Programming Pebble"
DescriptionLast year, after I ranted about swartwatches being useless, a bunch of people told me to look at Pebble - and they were right! This year, Pebble is releasing new devices, and a new OS and SDK revision, including the ability to write onboard 'native' apps in JavaScript. Let's see what it can do... |
| 11:45 |
Ricky Ng-Adam
- "Collaborative Learning"
DescriptionDemand for talented developers far exceeds resources available. One key to grow new talent is to help individuals with aptitudes and potential for software development to try out this new career path. Codeschools have proven faster and less expensive than universities but still demand a significant investment and have fixed learning cycles. Parallel to the rise of co-working and thanks to the availability of online content such as FreeCodeCamp, we propose a project-focused curriculum in a community with mentors where peers help each other learn new concepts and find work in their new chosen profession. |
| Lunch | |
| 12:15 | Lunch |
| Session 2 | |
| 13:30 |
Rowland Watkins
- "Actors and the Quest for Reliable Systems"
DescriptionSoftware development, especially multi-threaded, has become increasingly complex, which impacts our ability to reason and create reliable systems. Actor-based systems take a different approach, accepting failure, and providing strategies for recovery. In this talk we'll explore the motivations and rationale behind actors, example implementations, and how they might be used to increase system resilience. |
| 14:00 |
Andy Li
- "Why I chose to master a language no one knows"
DescriptionDevelopers are lifelong learners. There are new languages and frameworks becoming popular from time to time. In order to stay competitive, we have to learn constantly. But what should we learn and master? The hottest ones can maximize the number of our potential job matches; the oldest ones give us tons of tools and libraries to use; the latest ones gives us shinny cutting-edge features. I myself, however, chose a different path. In this talk, I will share my experience of how mastering a lesser known programming language (Haxe) gave me a chance to stand out, to speak at various conferences, to be known by oversea developers, and to get my first job. |
| 14:30 |
Jack Chen
- "Separating your data logic from business logic by PostgreSQL programming"
DescriptionObject-relational mapping (ORM) is convenient and widely used in many frameworks to manipulate objects without writing tedious SQL. But meanwhile it also brings a lot of problems on system performance, maintenance and scalability. On the other hand, programming SQL (e.g. PostgreSQL) for your data logic is perhaps not as bad as you think, and should not be ignored. |
| 15:00 |
Emmanuel Prochasson
&
Guy Freeman
- "A Day at the Races: a Data Science Extravaganza"
DescriptionAfter too many evenings fruitlessly fluttering away ten-dollar notes at the iconic Happy Valley Racecourse, we decided to use our Data Science skillz for the power of good: to make money betting on horse races. |
| Coffee Break | |
| 15:30 | Coffee Break |
| Session 3 | |
| 16:00 |
Thomas Pun
- "Shut up and take my money"
DescriptionWhat happened in between visitors entering their credit card number on your site to you receiving the fund? |
| 16:30 |
Daniel Chcouri
- "Understanding Javascript - JS core concepts"
DescriptionDouglas Crockford, JS guru and the inventor of the JSON format, once said that JS is "world's most misunderstood programming language". In the talk I'll cover key concepts of the JS language that I found to be critical for true understanding of the language, among other things I'll talk about Closures, the "this" word and prototypical inheritance. The talk is for developers that use JS and want to deepen their understanding of the language. |
| 17:00 |
Carla Souza
- "How to Raise your Inner DevOps Engineers"
Description"DevOps" is one of those buzzwords that, even though not everybody agrees on its definition, it is known of its importance in today's software industry. DevOps culture has a fast growing community, with daily new tools available to make every engineers' life better, faster, more efficient and more scalable. In this talk, I will speak about the DevOps culture, why it was born, why is it important and how flexible and dynamic it is. I will also talk about the crucial points of my life that directed me to get into this field and what you can do to help others and yourself to grow into a better engineer. |
| Closing & After Party | |
| 17:30 | Closing / Thank you |
| 19:00 | After Party |


Plugin Information |
|---|
View anything-goes-formatter on the plugin site for more information. |
This plugin allows you to use JavaScript inside your project description.
Caution
When JavaScript is added inside the description, it effectively has access to the user's session of the Jenkins, which can be then used to do operations on behalf of the user. There's an inherent security risk in this. Use with caution, only when you can trust all the users of your installation.
It's not sufficient to be able to trust users who are able to configure Jenkins itself, views, or projects, or update builds. Any logged in user can edit their own description (/user/username/configure
) and could add unsafe JavaScript to their user profile.
Changelog
Version 1.0 (Mar 14 2012)
- Initial version


One of the classic performance problems in Smalltalk is the performance of double-precision (64 bit) floating point operations. This is due to the fact that all numbers are objects in Smalltalk, and on current machines object references are 32 bits, with 1 or 2 bits reserved for tag bits, which is far too small to encode a double-precision floating point value. This is not a problem for integers, since 30 or 31 bits is plenty to represent numbers up to at least 1 billion. But a single precision floating point value with tag bits subtracted, which is all you can fit into an immediate object reference, has far too few digits of precision (about 7) for most floating point applications. Thus, they have to be allocated as real objects, and this causes a massive performance penalty of one or two orders of magnitude for double-precision floating point calculations, since a new object must be allocated for the result of every operation.
The Strongtalk system includes an experimental scheme for performing fast double-precision arithmetic without allocation. This scheme was not developed very far, and has several drawbacks and limitations:
It requires use of a special <FloatVal> type annotation that is not integrated with the type system, although it uses the same syntax. If this syntax is not used, normal allocated double precision operation is used.
It requires explicit conversion between boxed (allocated) and unboxed (optimized) doubles, and does not allow passing of unboxed doubles across method boundaries.
However, if a significant number of operations are combined in a single method, it can produce huge speedups by eliminating all the allocation for intermediate results. Click here to launch a primitive sample application that uses fast floating point to compute the Mandelbrot set. Use the "Control/Compute" menu item to run the program. You can compare the performance relate to both normal Smalltalk "boxed" floats, and to a C routine, using the options menu. The compute time in milliseconds is printed in the Transcript.


Profile
Developer, former editor and cameraman in the film industry. Have a keen interest in cinema, litterature, music, video games and programming. Always in search of new adventures.
Developer, former editor and cameraman in the film industry. Have a keen interest in cinema, litterature, music, video games and programming. Always in search of new adventures.
Languages : English (Score TOEIC : 925), C#, .NET, Java, JEE, C++, Angular, Javascript, Typescript, HTML, CSS, Bash
Softwares : Eclipse, Visual Studio, Phpstorm, IntelliJ, Visual Studio Code, Unity3D, Unreal Engine, Photoshop, Premiere Pro
Misc : Git, Unix, Linux, 35mm Camera , 16mm Camera , HD Camera
FullStack developer C#/Angular
WeRecruit, Rennes
January 2022-
Development of a SaaS recruitment platform Setup of CI/CD workflow Regular dependencies updates Database administration
Tools : .NET 6, Angular 14, C#, Typescript, Git, GitLab, GitLab CI, SQL Server, Azure
Software Engineer
SII, Nantes
March 2020-January 2022
Migrate a software from WinForms to WPF Go from .NET Framework 4.0 to 4.8. Migrate an application ASP.NET de .NET Framework 4.5. Go from .NET Framework to .Net Core 3.1 or superior. Go from aspx to Blazor.
Tools : .NET, WPF, WinForms, C#, Git, GitLab, Powershell, HTML, IIS Express, SQL Server
Software Engineer
Capgemini, Nantes
July 2018-March 2020
FullStack developer on a Webshop in the luxury sector. Environment working around PHP/javascript languages, Drupal and Magento CMS and Angular framework. Continuous integrated development in agile SAFe methodology.
Tools : PhpStorm, Magento, Drupal, Angular, Typescript, PHP, Javascript, Jenkins, Git, HTML5, CSS3, Docker, Akeneo, Bash.
Software Engineer
Capgemini, Nantes
May 2018-July 2018
Webshop maintenance in JEE, front-end development in javascript, JSP et CSS.
Tools : Eclipse, Jenkins, Maven, Hibernate, Java, Spring, Javascript, HTML5, CSS3.
Polymont IT, Nantes
February 2018-May 2018
JEE Applications maintenance in a continuous integration environnement.
Tools : Eclipse, Jenkins, Maven, Nexus, Hibernate, Java, Spring, Javascript, HTML5, CSS3.
CGI, Bordeaux
2016-2017
For a banking client for their big accounts management, JEE Applications maintenance in a continuous integration environnement. Maintenance and upgrade of UNIX IS, bash scripts creations and modifications.
Tools : Eclipse, Jenkins, Maven, Nexus, Hibernate, Java, Bash.
Cameraman
Kino Session, Bordeaux
2011-2015
Filming of various types of videos(short film, promotional videos event videos). In relation with the director, realize the film’s shots according to the detailed specifications.
Resource Magazine, New York
2010
Analyze shots, edit their event videos released on their webtv.
Editor
Kino Session, Bordeaux
2011-2015
Editing of various types of videos(short film, promotional videos event videos). In relation with the director, put together all the elements for the video according to the detailed specifications.
Resource Magazine, New York
2010
In a team of camera operators and editors cover the various magazine’s events and deliver videos of those events that feature on the website.
Bachelor’s Degree in Computer Sciences
IUT, Bordeaux
2015-2017
Study web-oriented and graphics oriented development. Websites and software creation in projects. Learning Design Pattern implementation. Learning Database manipulation and administration (SQL Server, OracleDB, mySQL). Learning 2D/3D programming, animation programming.
Languages: C#, C++, ASP.NET, Java, Ruby on Rails, Bash, Javascript, HTML5, CSS3, SQL ,mySQL.
Environments: Linux, Windows.
Tools : Eclipse, Visual Studio, VSCode, Hololens, IntelliJ, WebStorm, Unity3D,OracleDB, SQLServer
Bachelor’s Degree in Film and Cinema
ESRA, Rennes (France) & New York
2006-2010
Cinema/TV Shows : last discoveries : Everything Everywhere All at Once, Ted Lasso
Music : Guitarist, last discoveries : Boygenius
Photography/Video
Video Games : Currently playing Octopath Traveller 2, Elden Ring
Litterature : Currently reading Vita Nostra
Development : Creating games on Unity3D (C#, VSCode, .Net)


rng = check_random_state(random_state)
// Bounds
n_params = len(bounds)
lb, ub = extract_bounds(bounds)
// Default GP
if base_estimator is None:
if a < best:
next_x, best = x, a
next_x = space.inverse_transform(next_x.reshape((1, -1)))[0]
print(next_x)
next_y = func(next_x)
Xi = np.vstack((Xi, next_x))
yi.append(next_y)


Michael R. Ward
9344 Yorkshire Dr.
Saline, MI 48176
734-272-1434
<EMAIL_ADDRESS>Professional Objective
Software Developer on a leading-edge development team in a fun and innovative environment.
Executive Summary
- 30 years of experience
- Currently working in NancyFx, Entity Framework, AngularJS
- Architecture committee chair
- Author of many award wining/open source freeware programs (http://mike-ward.net)
- Expert in C# and ASP.Net
- Expert in WCF and Silverlight
- Expert in WIX
- Expert in MSBuild
- Practice test driven development
- Regular speaker at Siemens Tech Talks
- Extensive C/C++ including MFC/COM
-
Most Web-based technologies including Java, JavaScript, HTML, XHTML and server-side technologies
including CGI, ASP.NET and Zope.
- Proficient in most scripting languages including Python, Perl and JavaScript
- Very knowledgeable of encryption and security protocols
- Database driven Web design and programming experience
- Expert in XML and related protocols (XSLT, XML Schema, etc.)
- Web administration experience
- Network administration experience
- Patent Holder
Experience
Web Developer, INDS, Inc, Ann Arbor, MI, November 2012 - Present
INDS is a non-clinical drug trial analysis company and provides software services related to toxicology.
- Lead developer for Web applications
- Current project uses NancyFx (an alternative version of MVC for ASP.Net)
- Expert in JavaScript
- Proficient in AngularJS (have presented talks about Angular)
Software Engineer, Siemens Medical Systems, Ann Arbor, MI, December 2000 - November 2012
Siemens is the leading provider of Ultrasound machines in the United States. In addition, they have what
many consider to be the best image review and archive package in the industry.
- Currently working on an iPad medical imaging application using jQuery Mobile
-
Author of the first Silverlight application for medical image review. Spotlighted at the
Microsoft 2009 PDC.
-
SOAP and Web Services - Currently engaged in transforming our current products to
use SOAP over HTTP for use with Enterprise level medical imaging and archive systems.
- Build the first CI system used in Siemens Medical
-
Web Programmer - The web package provides many of image review and reporting features of the
flag-ship workstation products but with the advantage of being able to use it anywhere, any time.
-
Application Designer - Designed and developed most of the reporting technologies used in our
medical imaging and archive package. Made extensive use of XML, C# and related technologies.
-
Integration Expert - Designing a new data model to interface with enterprise class servers
designed by Siemens.
-
Patents - Have submitted 10 patents on technologies I've developed. Six are currently
accepted and under review.
Solution Architect, Influence L.L.C., Ann Arbor, MI, June 2000 - November 2000
Professional business services firm providing e-business solutions to a variety of clients.
-
Network Administration - NT server local area network and PBX phone system management
including Cisco router and switch installation and configuration.
-
Document Management System - Researched, installed and configured a document management system
for the entire company to replace a shared drive configuration that was large and unmanageable (Xerox
DocuShare).
-
White Papers - wrote white papers on XML technologies, Knowledge Management and Application
Infrastructure.
Technical Lead, Hilgraeve, Inc., Monroe, MI, July 1990 - June 2000
-
Principle Architect - Designed HyperSend.com, a unique Web-based application employing the
latest Internet technologies for secure document delivery across the Internet. HyperSend uses
state-of-the-art Secure Socket Layers, Blowfish, SHA, MD5, LZSS, Apache, Zope, C++ and Python on the
avant-garde CopperZ platform running Redhat Linux. HyperSend is supported by MySQL and soon will be
running Oracle. HyperSend employs an innovative combination of a traditional database backend, RAD
middleware, and a thin client architecture providing a leading-edge solution in secure document delivery
over the Internet.
-
Secure Internet Telephone - Now users can converse while transferring files. This includes
"Push to Talk" and Voice Activation (VOX) modes and utilizes the encryption and authentication modules I
wrote earlier for a truly secure and private connection.
-
Communications Expert - Pioneered several new technologies for Hilgraeve including: totally
new communications engine; an independent reliability layer guaranteeing accurate data delivery over any
medium (Internet, modems, mails slots, etc.); encryption and digital certificates using the latest
Microsoft CryptoAPI's; incorporated Microsoft Software Agents and added enhancements through a wrapper
class and class factory definitions.; developed Internet Locations Services (ILS) for instant messaging
features.
-
New Product Category - DropChute+ introduces a new product category, Personal File Delivery
Software. Alpha version wins Byte Magazine's Best of Comdex at the Spring 1997 show.
-
#1 Again! - In a head-to-head comparison with Procomm and CrossTalk,
HyperACEESS for
Windows 95 and NT
wins PC Magazine's Editors' Choice for 1997.
-
Logo Guru - First non-Microsoft program to support IntelliMouse?. Awarded logo
compliance for Office 97?, Windows 95? and Windows NT?.
- Internet Smart - Developed the WinSock, Telnet and TAPI modules used by our programs.
-
MFC, OLE and C++ Proficient - Technical lead for HyperACCESS for Windows 95 and NT.
This MFC based program implements many of the newest Microsoft technologies including ActiveX
Scripting and Automation, Document Object Servers, OLE Drag & Drop, and Structured Storage (Compound
Files).
-
Remote Control Wizard - Industry leading KopyKat for OS/2 includes many pioneering
features such as single line multiplexing and advanced image compression.
-
Graphical Talent - Technical lead for HyperACCESS for OS/2. Full Presentation Manager
program including graphics viewer capable of displaying graphics as they are downloaded. Program is
extensively multithreaded.
-
Industry Leader - Developed the widely acclaimed applet HyperTerminal included in every
copy of Windows 95. And in a 3 month team-effort put forth HyperACCESS Lite for OS/2 which
ships with every copy of OS/2 Warp. These programs have also been translated into more than 30
languages including Far East languages.
-
Patent Holder - Co-developer of CommSense? (Patent #5,553,271), a technology that
automatically detects communications and terminal settings. This technology won Hilgraeve contracts to
develop the Microsoft and IBM applets.
-
Award Winning Applications - Member of the three programmer team that developed the award
winning HyperACCESS for Windows. Best buy 1993 PC World. Top rating of 9.4 by InfoWorld
(thought by some to be the highest-rating ever given to any program by InfoWorld). Recommended, Windows
Magazine. Purchased later by Delrina Inc. and marketed as WinComm Pro. Same team developed
HyperACCESS/5, the venerable award-winning favorite for DOS and HyperACCESS/5 for OS/2, the
recognized leader in multithreaded OS/2 communications.
-
Technically Competent - Recognized as a "can do" developer. I'm often given the problems no
one else can solve. My skill set includes extensive C, C++, MFC, OLE and Assembly ranging
from bit-bashing at the hardware level to elegant high-level interfaces.
-
Imaginative Designer - InfoWorld and Software Digest rate our program interfaces as nearly
flawless.
-
Senior Software Engineer, Electrocon International, Inc., Ann Arbor, MI October 1988 - July
1990
-
Versatile - Programmed projects in Windows and OS/2 PM using C,
FORTRAN, Pascal, and Assembly .
-
Proven Performance - Designed and implemented a graphics analysis tool in Windows which
company claims to be best in the industry. Co-authored article in IEEE Journal (CAP) on the
implementation of the program.
-
Senior Computer Specialist, Computer Sciences Corp., Ann Arbor MI, May 1985 - October
1988
-
Diverse Experience - All phases of data processing. Supervisor's performance appraisal:
"Michael has the most diverse set of duties of any CSC position in Ann Arbor. His job requires expertise
across the entire range of ADP software and hardware functions, from applications to communications and
from micros to mainframes."
-
Problem Solver - Improved graphics system. Supervisor: "Michael's achievements in graphics
projects deserve special mention, since they yielded an improved, more flexible product with faster
turnaround and lower costs to the user."
-
Leadership - Lead analyst in conversion of mainframe data and applications with
no loss of
production time
. Supervisor: "Michael has the temperament and people skills to become an excellent
supervisor."
-
Technically Diverse - Supervisor: "Michael's skills list demonstrates both the breadth of his
technical competence and his willingness to tackle any assignment that comes his way."
Programmer Analyst, University of Michigan, Ann Arbor MI, May 1984 - May 1985
- Managed a $100,000 annual computer services budget.
- Installed and serviced a network of microcomputers.
Education and Professional Development
-
The University of Michigan
College of Engineering
B.S. Atmospheric & Oceanic Sciences, 1983
-
Eastern Michigan University
Graduate School of Business Administration
Completed 24 hours of course work in CIS
- Codemash 2014
- Presented at SEM-JS on AngularJS
- Codemash 2013
- Codemash 2012
- Microsoft Build Conference 2011
- Codemash 2011
- Codemash 2010
- PDC 2009, LA
- Codemash 2009
- PDC 2008, LA
- Codemash 2008
- C# Training, October 2002, Ann Arbor, MI
- Python/Zope Conference, January 2000, Arlington WV
- Hilgraeve Strategic Planning Conference, March 1998
- Visual C++ Developers Conference, March, 1997, Orlando, FL
- Visual C++ Developers Conference, July 1996, San Franscisco, CA
- Microsoft Professional Developers Conference, March 1996, San Franscisco, CA
- Hilgraeve Strategic Planning Conference, January 1996
- First Annual MFC Developers Conference, May 1995, San Jose, CA
- Managing Engineers, November 1994, Ann Arbor, MI.
- Microsoft Professional Developers Conference, December 1993, Anaheim, CA.
- IBM Mirrors Development Workshop, August 1992, West Palm Beach, FL.
- Microsoft Windows NT Porting Lab, January 1992, Redmond, WA.
- Microsoft Windows NT Developer Conference, October 1991, Redmond, WA.
Other Facts
Considered a fast learner ... Excellent communications skills ... Twenty years of experience ...
Outdoor activities including camping and biking ... Licensed private pilot ... Brown belt
in Aikido ... Darn good chocolate-chip cookie maker.


Part B: -ed and T sounds
- /
t/ “blessed” “laughed” “relaxed”
- /
d/ “entered” “sneezed” “borrowed”
- /
əd/ or /ɪd/ “started” “ended” “excited”
- True /
t/ “tomorrow” “today” “ten”
- Quick d /
d/ “butter” “water” “later”
- Omitted t /
t/ “twenty” “advantage” “internet”
-ed and T sounds
-ed and T sounds: Male Edition


Skip to main content
JavaScript and TypeScript Practice
Infinate Scroll
Form Validation
Flip Counter


--- layout: post date: 2010-01-18 time: "09:00:00" authors: ["Greg Wilson"] title: Was Designed To, But Didn't tags: ["Opinion"] ---
Michael Clarke has written a thoughtful post exploring why the web hasn't disrupted scientific publishing, even though it was designed to do exactly that.


--- layout: page title: Investigative and Non-Fiction Reporting description: Report the world around you background: '/img/t-investigate.jpg' ---
An investigative-reporting podcast is one that seems to work by way of inductive or deductive reasoning. That is, the author can accumulate and examine details piece-by-piece, ultimately creating a rich, focused picture. Or they can start with an overarching claim--a hypothesis--and see if specifics support or collapse it. Non-fiction podcasts can work in similar ways, though perhaps they come more from a place of documentary filmmaking or storytelling as opposed to forensics or journalism.
Come up with an idea and make a plan.
Do some research about your investigation or non-fiction story. Research the people involved. Who are they? What do they care about?
Come up with a list of places you need to go to and people you need to speak with.
Come up with questions for your interview subjects. In the biz, this is called your “Q Line.” You can share these questions with them before the recorded interview--or not.
Set times and places for site visits and interviews.
Meet your interview subjects and record your interviews. Before you record, make sure to confirm good sound levels. Don’t be afraid to throw out your Q Line if it’s not working or if you improvisationally come across better conversation. To be recording is to be getting your “Tape.”
Finished recording interviews, share a release form with your interview subjects and have them sign it.
When visiting sites, pay attention to any sounds that could contribute to your investigation or story. Take notes about ideas and impressions you have or details and specifics you notice. As they say in the world of journalism, “Get the name of the dog…”
Transcribe all your Tape. O Transcribe is a useful tool for this.
Review all your recordings and transcriptions, cut out the best parts, and organize them into “Tracks.” You also need to write your “Acts.” Your Acts are what you’ll use to set up or deal with your Tracks.
Record yourself reading your Acts.
Determine if you need music and sound design.
Create, license, or find Creative Commons music and sounds.
Put everything together with Audacity--your Acts, Tracks, music, and sounds.
Share the draft of your podcast and get feedback. Share it with your interview subjects--or not.
Consider, reject, or incorporate feedback. Reflect on your process and the meaning of your podcast. Repeat previous steps.
In a spreadsheet, enter the metadata for all the files you created or used.
Finish your complete transcript.  It will be a combination of your Acts, Tracks, and descriptions of any of the music and sounds you used.
Decide, as a whole, whether or not your podcast should have a Creative Commons designation.
If you are going to put your podcasts online, do an audit of your online safety and security. Do you have safe passwords? Consider making passwords using the “diceware” method and using LastPass. If you Google yourself, what information do data brokers have about you? Consider contacting data brokers and requesting they remove your information.
No! The steps above are a guide--not the rule. You might do things in a different order or not at all. For example, you might start with no questions for your interview subjects, and, instead, leave things to the moment and improvisation. You might reject a three-act or five-act storytelling structure for a design that’s from a different tradition. You could even try to make a podcast without any scripted parts and leave people and places to speak wholly for themselves.


HMTMCSE Education
User Name
Profile
Logout
Dashboard
Orders
Products
Customers
Reports
Integrations
Saved reports
Current month
Last quarter
Social engagement
Year-end sale
Dashboard
Search
Create
Reload
#
Header
Header
Header
Header
Action
1,001
Lorem
ipsum
dolor
sit
View
Edit
Delete
1,002
amet
consectetur
adipiscing
elit
View
Edit
Delete
1,003
Integer
nec
odio
Praesent
View
Edit
Delete
1,003
libero
Sed
cursus
ante
View
Edit
Delete
10
20
50
100
Prev
1
2
3
Next


Added 55 new components. In particular, added new package Thermal.HeatTransfer for modeling of lumped heat transfer, added model LossyGear in Mechanics.Rotational to model gear efficiency and bearing friction according to a new theory in a robust way, added 10 new models in Electrical.Analog and added several other new models and improved existing models.
New components
| Modelica.Blocks. | |
| Continuous.Der | Derivative of input (= analytic differentiations) |
| Examples | Demonstration examples of the components of this package |
| Nonlinear.VariableLimiter | Limit the range of a signal with variable limits |
| Modelica.Blocks.Interfaces. | |
| RealPort | Real port (both input/output possible) |
| IntegerPort | Integer port (both input/output possible) |
| BooleanPort | Boolean port (both input/output possible) |
| SIMO | Single Input Multiple Output continuous control block |
| IntegerBlockIcon | Basic graphical layout of Integer block |
| IntegerMO | Multiple Integer Output continuous control block |
| IntegerSignalSource | Base class for continuous Integer signal source |
| IntegerMIBooleanMOs | Multiple Integer Input Multiple Boolean Output continuous control block with same number of inputs and outputs |
| BooleanMIMOs | Multiple Input Multiple Output continuous control block with same number of inputs and outputs of Boolean type |
| BusAdaptors | Components to send signals to the bus or receive signals from the bus |
| Modelica.Blocks.Math. | |
| RealToInteger | Convert real to integer signals |
| IntegerToReal | Convert integer to real signals |
| Max | Pass through the largest signal |
| Min | Pass through the smallest signal |
| Edge | Indicates rising edge of Boolean signal |
| BooleanChange | Indicates Boolean signal changing |
| IntegerChange | Indicates integer signal changing |
| Modelica.Blocks.Sources. | |
| IntegerConstant | Generate constant signals of type Integer |
| IntegerStep | Generate step signals of type Integer |
| Modelica.Electrical.Analog.Basic. | |
| HeatingResistor | Temperature dependent electrical resistor |
| OpAmp | Simple nonideal model of an OpAmp with limitation |
| Modelica.Electrical.Analog.Ideal. | |
| IdealCommutingSwitch | Ideal commuting switch |
| IdealIntermediateSwitch | Ideal intermediate switch |
| ControlledIdealCommutingSwitch | Controlled ideal commuting switch |
| ControlledIdealIntermediateSwitch | Controlled ideal intermediate switch |
| IdealOpAmpLimited | Ideal operational amplifier with limitation |
| IdealOpeningSwitch | Ideal opener |
| IdealClosingSwitch | Ideal closer |
| ControlledIdealOpeningSwitch | Controlled ideal opener |
| ControlledIdealClosingSwitch | Controlled ideal closer |
| Modelica.Electrical.Analog.Lines. | |
| TLine1 | Lossless transmission line (Z0, TD) |
| TLine2 | Lossless transmission line (Z0, F, NL) |
| TLine2 | Lossless transmission line (Z0, F) |
| Modelica.Icons. | |
| Function | Icon for a function |
| Record | Icon for a record |
| Enumeration | Icon for an enumeration |
| Modelica.Math. | |
| tempInterpol2 | temporary routine for vectorized linear interpolation (will be removed) |
| Modelica.Mechanics.Rotational. | |
| Examples.LossyGearDemo1 | Example to show that gear efficiency may lead to stuck motion |
| Examples.LossyGearDemo2 | Example to show combination of LossyGear and BearingFriction |
| LossyGear | Gear with mesh efficiency and bearing friction (stuck/rolling possible) |
| Gear2 | Realistic model of a gearbox (based on LossyGear) |
| Modelica.SIunits. | |
| Conversions | Conversion functions to/from non SI units and type definitions of non SI units |
| EnergyFlowRate | Same definition as Power |
| EnthalpyFlowRate | Real (final quantity="EnthalpyFlowRate", final
unit="W") |
| Modelica. | |
| Thermal.HeatTransfer | 1-dimensional heat transfer with lumped elements |
| ModelicaAdditions.Blocks.Discrete. | |
| TriggeredSampler | Triggered sampling of continuous signals |
| TriggeredMax | Compute maximum, absolute value of continuous signal at trigger instants |
| ModelicaAdditions.Blocks.Logical.Interfaces. | |
| BooleanMIRealMOs | Multiple Boolean Input Multiple Real Output continuous control block with same number of inputs and outputs |
| RealMIBooleanMOs | Multiple Real Input Multiple Boolean Output continuous control block with same number of inputs and outputs |
| ModelicaAdditions.Blocks.Logical. | |
| TriggeredTrapezoid | Triggered trapezoid generator |
| Hysteresis | Transform Real to Boolean with Hysteresis |
| OnOffController | On-off controller |
| Compare | True, if signal of inPort1 is larger than signal of inPort2 |
| ZeroCrossing | Trigger zero crossing of input signal |
| ModelicaAdditions. | |
| Blocks.Multiplexer.Extractor | Extract scalar signal out of signal vector dependent on IntegerRealInput index |
| Tables.CombiTable1Ds | Table look-up in one dimension (matrix/file) with only single input |
Package-specific Changes
block
class, which have not been already of block typepartial
modelsClass-specific Changes
Modelica.SIunits
Removed final
from quantity attribute for
Mass and MassFlowRate.
Modelica.Blocks.Math.Sum
Implemented avoiding algorithm section, which would lead to expensive function calls.
Modelica.Blocks.Sources.Step
block Step "Generate step signals of type Real" parameter Real height[:]={1} "Heights of steps"; // parameter Real offset[:]={0} "Offsets of output signals"; // parameter SIunits.Time startTime[:]={0} "Output = offset for time < startTime"; // extends Interfaces.MO (final nout=max([size(height, 1); size(offset, 1); size(startTime, 1)])); extends Interfaces.SignalSource(final nout=max([size(height, 1); size(offset, 1); size(startTime, 1)]));
Modelica.Blocks.Sources.Exponentials
Replaced usage of built-in function exp
by
Modelica.Math.exp.
Modelica.Blocks.Sources.TimeTable
Interface definition changed from
parameter Real table[:, :]=[0, 0; 1, 1; 2, 4] "Table matrix (time = first column)";
to
parameter Real table[:, 2]=[0, 0; 1, 1; 2, 4] "Table matrix (time = first column)";
Did the same for subfunction getInterpolationCoefficients.
Bug in getInterpolationCoefficients for startTime <> 0 fixed:
... end if; end if; // Take into account startTime "a*(time - startTime) + b" b := b - a*startTime; end getInterpolationCoefficients;
Modelica.Blocks.Sources.BooleanStep
block BooleanStep "Generate step signals of type Boolean" parameter SIunits.Time startTime[:]={0} "Time instants of steps"; parameter Boolean startValue[size(startTime, 1)]=fill(false, size(startTime, 1)) "Output before startTime"; extends Interfaces.BooleanSignalSource(final nout=size(startTime, 1)); equation for i in 1:nout loop // outPort.signal[i] = time >= startTime[i]; outPort.signal[i] = if time >= startTime[i] then not startValue[i] else startValue[i]; end for; end BooleanStep;
Modelica.Electrical.Analog
Corrected table of values and default for Beta by dividing them by 1000 (consistent with the values used in the NAND-example model):
Corrected parameter defaults, unit and description for TrapezoidCurrent. This makes the parameters consistent with their use in the model. Models specifying parameter values are not changed. Models not specifying parameter values did not generate trapezoids previously.
Icon layer background changed from transparent to white:
Basic.Transformer: Replaced invalid escape characters '\ ' and '\[newline]' in documentation by '|'.
Modelica.Mechanics.Rotational
Removed arrows and names documentation from flanges in diagram layer
Modelica.Mechanics.Rotational.Interfaces.FrictionBase
Modelica.Mechanics.Rotational.Position
Replaced reinit
by initial
equation
Modelica.Mechanics.Rotational.RelativeStates
Bug corrected by using modifier stateSelect =
StateSelect.prefer
as implementation
Modelica.Mechanics.Translational.Interfaces.flange_b
Attribute fillColor=7 added to Rectangle on Icon layer, i.e., it is now filled with white and not transparent any more.
Modelica.Mechanics.Translational.Position
Replaced reinit
by initial
equation
Modelica.Mechanics.Translational.RelativeStates
Bug corrected by using modifier stateSelect =
StateSelect.prefer
as implementation
Modelica.Mechanics.Translational.Stop
Use stateSelect = StateSelect.prefer
.
Modelica.Mechanics.Translational.Examples.PreLoad
Improved documentation and coordinate system used for example.
ModelicaAdditions.Blocks.Nonlinear.PadeDelay
Replaced reinit
by initial
equation
ModelicaAdditions.HeatFlow1D.Interfaces
Definition of connectors Surface_a and
Surface_b:
flow SIunits.HeatFlux q;
changed to flow
SIunits.HeatFlowRate q;
MultiBody.Parts.InertialSystem
Icon corrected.


--- title: Losses keywords: fastai sidebar: home_sidebar summary: "Loss callback functions" description: "Loss callback functions" nb_path: "nbs/18_losses.ipynb" ---
Loss function callbacks compute some loss value from the current batch state and add the resulting value to BatchState.loss
.
LossCallback
provides a simple hook for custom loss functions. Any object with a from_batch_state
method that returns a scalar value can be passed to LossCallback
. Ex:
class MyLoss():
def from_batch_state(self, batch_state):
loss = self.do_loss_calculation()
return loss
The PolicyLoss
interfaces with any of the BasePolicy
subclasses like PolicyGradient
, TRPO
or PPO
.
PolicyLoss
can optionally contain a value_head
, a model to predict state values. The code will look for a batch_state.value_input
attribute, which is typically set by Agent.get_model_outputs


Shearer picks four Liverpool stars in his Team of the Season so far
Alan Shearer has included four Liverpool players in his Premier League team of the season so far, while only Kevin De Bruyne makes the cut from Manchester City’s squad.
After 12 games played, Jurgen Klopp’s side remain unbeaten and are eight points clear at the top of the Premier League.
City, meanwhile, find themselves nine points behind their title rivals following their 3-1 defeat at Anfield before the international break.
And as a result, Shearer believes only De Bruyne has been good enough to take a place in his Premier League team of the season so far.
Advertisement Advertisement
Sheffield United currently sit fifth in the Premier League after an excellent start and two of their players are included – Dean Henderson and centre-back John Egan.
They are joined in defence by Liverpool’s star full-backs Trent Alexander-Arnold and Andy Robertson, while Leicester City’s Caglar Soyuncu makes up the back line.
In midfield, Liverpool’s midfield anchor Fabinho sits behind Sadio Mane, James Maddison and De Bruyne.
And in attack, Shearer has gone for a two-man front line as Tammy Abraham partners Jamie Vardy.


Right-click and drag to pan the camera. Left-click and drag to orbit around the light field. Scroll wheel zooms in and out.
Source code on Github


| Class | Description |
|---|---|
| ANSIColorUtils | |
| CauldronUtils | |
| FileUtil | |
| HttpUtil | |
| IOUtil | |
| JarLoader | |
| JarTool | |
| MD5Util | |
| Number | |
| ServerEula | |
| ThermiteRandom |
A subclass of java.util.random that implements the Xorshift random number
generator
- it is 30% faster than the generator from Java's library - it produces
random sequences of higher quality than java.util.Random - this class also
provides a clone() function
Usage: XSRandom rand = new XSRandom(); //Instantiation x = rand.nextInt();
//pull a random number
To use the class in legacy code, you may also instantiate an XSRandom object
and assign it to a java.util.Random object: java.util.Random rand = new
XSRandom();
for an explanation of the algorithm, see
http://demesos.blogspot.com/2011/09/pseudo-random-number-generators.html
|


Chamisa to address Zimbabweans tomorrow at MDC offices
by Mandla NdlovuMDC leader Nelson Chamisa will address Zimbabweans at the Morgan Tsvangirai House after the police banned his planned address at the Africa Unity Square.
Addressing the media MDC Spokesperson Daniel Molokele said all Zimbabweans are welcome to attend the event.
The address has been termed Hope of the Nation Address.
Watch the video below:


Joey Jones blasts Paul Krugman's New York Times column calling Republicans 'pretend' patriots
After a New York Times op-ed called out Republicans for "pretending to be patriots," retired U.S. Marine Joey Jones pushed back on Thursday, taking issue with the argument put forth by economist Paul Krugman.
“The fact that the Republican Party is viewed as the most patriotic is not a talking point for the Republican Party. This is an observation of middle-of-the-road swing voters. ... This op-ed was probably written in an echo chamber of self-love and denial. It's very naive, it gets a lot of things wrong,” Jones told “Fox & Friends.”
2020 DEMS RAMP UP CALLS TO MANDATE ASSAULT WEAPONS BUYBACK: ‘ALL OF THEM’
In the column, titled “Republicans Only Pretend to Be Patriots,” Krugman argued that Republicans' acceptance of President Trump's behavior is unpatriotic.
CHICAGO MAYOR CLASHES WITH CRUZ OVER GUN VIOLENCE: 'KEEP OUR NAME OUT OF YOUR MOUTH'
“After all, a true patriot is willing to make some sacrifice, to give up some personal or policy goal, in the national interest. Can anyone point to any prominent figure in the modern Republican Party who has done that?” he wrote.
Krugman wrote that "Republicans were never the patriots they pretended to be, but at this point they've pretty much crossed the line into being foreign agents" in defense of Trump.
Jones took issue with the Nobel laureate's use of the word "sacrifice" to make his point.
“Someone introduce him to [Texas Republican Rep.] Dan Crenshaw or [Florida Republican Rep.] Brian Mast,” said Jones, who lost both of his legs in an explosion in Afghanistan in 2010.
CLICK HERE TO GET THE FOX NEWS APP
“Brian Mast had his right hand sewn to his stomach as he learned to walk and went to school on his path to Congress and so if you want to talk about sacrifice, I’m willing to admit there’s plenty on both sides and for anyone to write in an op-ed that for some reason Republicans aren’t willing to sacrifice, to me, shouldn’t be printed on paper.”
Jones said that Republicans touting pride in the country and the belief in hard work “does not mean the left can’t do the same.”


fun getURL(locale: Locale): String
Get the URL to the docs site where the error codes are hosted.
Note that the correct docs site link is likely to depend on the following:
The returned URL must be the link the to the error code table in the documentation.
locale
- The locale of the link
Return
The URL of the docs site, to be printed in the logs


Survey about You
First Name
Last Name
Gender
Age
Occupation
Personality
What animal do you associate with?
Think of a colour
Think of a place
Do you like people?
Do you like to be indoors or outdoors?
Ambitions
What is your passion?
What are your hobbies?
What would you like to achieve in 5 years?
Note to Self
Name 3 things that you appreciate about yourself
Name 3 things that you have overcome in your life
Name 3 things that you love about your body
Write a love letter to yourself in one sentence
Click on your mood for the day
Sad
Happy
Irritated
Calm
Indifferent
Angry
Excited
Longely
Complete this form everyday to keep track and improve yourself!


Authenticate with SharePoint using SCOM API
More...
|
| static ClientContext | GetAppOnlyContext (string siteUrl, string clientId, string clientSecret) |
| | Retrieve the SharePoint client app only context via app client id and secret key in order to make requests using SCOM More...
|
| |
| static ClientContext | GetUserContext (string siteUrl, string username, string password) |
| | Retrieve the SharePoint client context user context via username and password in order to make requests using SCOM More...
|
| |
| static ClientContext | GetUserContext (string siteUrl, string username, SecureString password) |
| | Retrieve the SharePoint client context user context via username and password in order to make requests using SCOM More...
|
| |
Authenticate with SharePoint using SCOM API
◆ GetAppOnlyContext()
| static ClientContext JBToolkit.SharePoint.CSOM.Authentication.GetAppOnlyContext |
( |
string |
siteUrl, |
|
|
string |
clientId, |
|
|
string |
clientSecret |
|
) |
| |
|
static |
Retrieve the SharePoint client app only context via app client id and secret key in order to make requests using SCOM
- Parameters
-
| siteUrl | SharePoint site URL |
| clientId | App client ID |
| clientSecret | App secret key |
- Returns
- SharePoint client app only context
◆ GetUserContext() [1/2]
| static ClientContext JBToolkit.SharePoint.CSOM.Authentication.GetUserContext |
( |
string |
siteUrl, |
|
|
string |
username, |
|
|
SecureString |
password |
|
) |
| |
|
static |
Retrieve the SharePoint client context user context via username and password in order to make requests using SCOM
- Parameters
-
| siteUrl | SharePoint site URL |
| username | Credentials username (email) |
| password | Credentials password |
- Returns
- SharePoint client user context
◆ GetUserContext() [2/2]
| static ClientContext JBToolkit.SharePoint.CSOM.Authentication.GetUserContext |
( |
string |
siteUrl, |
|
|
string |
username, |
|
|
string |
password |
|
) |
| |
|
static |
Retrieve the SharePoint client context user context via username and password in order to make requests using SCOM
- Parameters
-
| siteUrl | SharePoint site URL |
| username | Credentials username (email) |
| password | Credentials password |
- Returns
- SharePoint client user context
The documentation for this class was generated from the following file:
- D:/OneDrive/Documents/Work/Repositories/JB.Toolkit/JB.Toolkit/SharePoint/CSOM/Authentication.cs


Khalid bin Salman Discusses Counter-Terrorism Efforts with Omani Officials
Saudi Deputy Defense Minister Prince Khalid bin Salman held talks in Muscat on Monday with Oman’s minister in charge of defense affairs Badr bin Saud bin Harib Al-Busaeedi.
Discussions focused on bilateral relations and efforts to protect their common border.
They also tackled efforts to counter terrorism and extremism and ways to bolster the current military cooperation between their countries.
Prince Khalid also met with Minister for Sultan's Bureau Affairs General Sultan bin Mohammed Al-Numani.
The Saudi minister had arrived in Oman earlier on Monday on an official visit.