Android Developer Security Guide
This is a summary of the Android Developer Security Guide.
Overview
The following core security features help you build secure apps:
-
The Android Application Sandbox, which isolates your app data and code execution from other apps.
-
An application framework with robust implementations of common security functionality such as cryptography, permissions, and secure IPC.
-
Technologies like ASLR, NX, ProPolice, safe_iop, OpenBSD dlmalloc, OpenBSD calloc, and Linux mmap_min_addr to mitigate risks associated with common memory management errors.
-
An encrypted file system that can be enabled to protect data on lost or stolen devices.
-
User-granted permissions to restrict access to system features and user data.
-
Application-defined permissions to control application data on a per-app basis.
Data Storage
The most common security concern for an application on Android is whether the data that you save on the device is accessible to other apps.
There are three fundamental ways to save data on the device:
-
Internal Storage
-
By default, files that you create on internal storage are accessible only to your app. Android implements this protection, and it’s sufficient for most applications.
-
Avoid the
MODE_WORLD_WRITEABLE
orMODE_WORLD_READABLE
modes for IPC files because they do not provide the ability to limit data access to particular applications, nor do they provide any control of data format. If you want to share your data with other app processes, instead consider using a content provider, which offers read and write permissions to other apps and can make dynamic permission grants on a case-by-case basis.
-
-
External Storage
-
Files created on external storage, such as SD cards, are globally readable and writable. Because external storage can be removed by the user and also modified by any application, don’t store sensitive information using external storage.
-
You should Perform input validation when handling data from external storage as you would with data from any untrusted source. You should not store executables or class files on external storage prior to dynamic loading. If your app does retrieve executable files from external storage, the files should be signed and cryptographically verified prior to dynamic loading.
-
-
Content Providers
-
Content providers offer a structured storage mechanism that can be limited to your own application or exported to allow access by other applications. If you do not intend to provide other applications with access to your ContentProvider, mark them as
android:exported=false
in the application manifest. Otherwise, set theandroid:exported
attribute to true to allow other apps to access the stored data. -
If you are using a content provider for sharing data between only your own apps, it is preferable to use the
android:protectionLevel
attribute set to signature protection. Signature permissions do not require user confirmation, so they provide a better user experience and more controlled access to the content provider data when the apps accessing the data are signed with the same key.
-
Permissions
Android permissions are ranked in four different categories based on the protection level they offer:
-
Normal: the lower level of protection. It gives the apps access to isolated application-level feature, with minimal risk to other apps, the user or the system. It is granted during the installation of the App. It is also the default value for the cases when no protection level is specified. Example:
android.permission.INTERNET
-
Dangerous: This permission usually gives the app control over the user data or over the device that impacts the user. This type of permission may not be granted at installation time, leaving it to the user to decide whether the app should have the permission or not. Example:
android.permission.RECORD_AUDIO
-
Signature: This permission is granted only if the requesting app was signed with the same certificate as the app that declared the permission. If the signature matches, the permission is automatically granted. Example:
android.permission.ACCESS_MOCK_LOCATION
-
SystemOrSignature: Permission only granted to the apps embedded in the system image or that were signed using the same certificated as the app that declared the permission. Example:
android.permission.ACCESS_DOWNLOAD_MANAGER
IP Networking
-
You should use HTTPS over HTTP anywhere that HTTPS is supported on the server, because mobile devices frequently connect on networks that are not secured, such as public Wi-Fi hotspots. Authenticated, encrypted socket-level communication can be easily implemented using the SSLSocket class.
-
Some applications use localhost network ports for handling sensitive IPC. You should not use this approach because these interfaces are accessible by other applications on the device. Instead, use an Android IPC mechanism where authentication is possible, such as with a Service. Binding to
INADDR_ANY
is worse than using loopback because then your application may receive requests from anywhere. -
Make sure that you don’t trust data downloaded from HTTP or other insecure protocols. This includes validation of input in WebView and any responses to intents issued against HTTP.
Telephony Networking
-
Beware that SMS is neither encrypted nor strongly authenticated on either the network or the device. In particular, any SMS receiver should expect that a malicious user may have sent the SMS to your application. Don’t rely on unauthenticated SMS data to perform sensitive commands.
-
Also, you should be aware that SMS may be subject to spoofing and/or interception on the network. On the Android-powered device itself, SMS messages are transmitted as broadcast intents, so they may be read or captured by other applications that have the
READ_SMS
permission.
Input Validation
-
Insufficient input validation is one of the most common security problems affecting applications, regardless of what platform they run on. Android has platform-level countermeasures that reduce the exposure of applications to input validation issues, and you should use those features where possible.
-
If you are using native code, any data read from files, received over the network, or received from an IPC has the potential to introduce a security issue. The most common problems are buffer overflows, use after free, and off-by-one errors. Android provides a number of technologies like ASLR and DEP that reduce the exploitability of these errors, but they don’t solve the underlying problem. You can prevent these vulnerabilities by carefully handling pointers and managing buffers.
-
If you are using data within queries that are submitted to an SQL database or a content provider, SQL injection may be an issue. The best defense is to use parameterized queries, as is discussed in the above section about content providers. Limiting permissions to read-only or write-only can also reduce the potential for harm related to SQL injection.
-
You should make sure to use well-structured data formats and verify that the data conforms to the expected format. While blacklisting of characters or character-replacement can be an effective strategy, these techniques are error prone in practice and should be avoided when possible.
Handling User Data
-
In general, the best approach for user data security is to minimize the use of APIs that access sensitive or personal user data. If you have access to user data and can avoid storing or transmitting it, don’t store or transmit the data.
-
Consider if there is a way that your application logic can be implemented using a hash or non-reversible form of the data.
-
For example, your application might use the hash of an email address as a primary key to avoid transmitting or storing the email address. This reduces the chances of inadvertently exposing data, and it also reduces the chance of attackers attempting to exploit your application.
-
If your app requires access to sensitive data, evaluate whether you need to transmit it to a server or you can run the operation on the client. Consider running any code using sensitive data on the client to avoid transmitting user data.
-
Also, make sure that you do not inadvertently expose user data to other applications on the device through overly permissive IPC, world-writable files, or network sockets. Overly permissive IPC is a special case of leaking permission-protected data.
-
If a GUID is required, create a large, unique number and store it. Don’t use phone identifiers such as the phone number or IMEI, which may be associated with personal information.
-
Be careful when writing to on-device logs. In Android, logs are a shared resource and are available to an application with the
READ_LOGS
permission.
Using Webviews
-
Because WebView consumes web content that can include HTML and JavaScript, improper use can introduce common web security issues such as XSS. Android includes a number of mechanisms to reduce the scope of these potential issues by limiting the capability of WebView to the minimum functionality required by your application
-
If your application doesn’t directly use JavaScript within a WebView, do not call
setJavaScriptEnabled()
. By default, WebView does not execute JavaScript, so XSS is not possible. -
If your application accesses sensitive data with a WebView, you may want to use the
clearCache()
method to delete any files stored locally. You can also use server-side headers such asno-cache
to indicate that an application should not cache particular content. -
Use
addJavaScriptInterface()
with particular care because it allows JavaScript to invoke operations that are normally reserved for Android applications. If you use it, exposeaddJavaScriptInterface()
only to web pages from which all input is trustworthy. In general, the Android documentation recommends exposingaddJavaScriptInterface()
only to JavaScript that is contained within your application APK.
Handling Credentials
-
To make phishing attacks more conspicuous and less likely to be successful, minimize the frequency of asking for user credentials. Instead use an authorization token and refresh it.
-
Where possible, don’t store user names and passwords on the device. Instead, perform initial authentication using the user name and password supplied by the user, and then use a short-lived, service-specific authorization token.
-
Services that are accessible to multiple applications should be accessed using AccountManager. If possible, use the AccountManager class to invoke a cloud-based service and don’t store passwords on the device.
-
After using AccountManager to retrieve an Account, use CREATOR before passing in any credentials so that you do not inadvertently pass credentials to the wrong application.
-
If credentials are used only by applications that you create, you can verify the application that accesses the AccountManager using
checkSignature()
. Alternatively, if only one application uses the credential, you might use a KeyStore for storage.
Cryptography
-
Use a secure random number generator, SecureRandom, to initialize any cryptographic keys generated by KeyGenerator. Use of a key that is not generated with a secure random number generator significantly weakens the strength of the algorithm and may allow offline attacks.
-
If you need to store a key for repeated use, use a mechanism, such as KeyStore, that provides a mechanism for long term storage and retrieval of cryptographic keys.
IPC
-
Some apps attempt to implement IPC using traditional Linux techniques such as network sockets and shared files. However, you should instead use Android system functionality for IPC such as Intent, Binder or Messenger with a Service, and BroadcastReceiver. The Android IPC mechanisms allow you to verify the identity of the application connecting to your IPC and set a security policy for each IPC mechanism.
-
Many of the security elements are shared across IPC mechanisms. If your IPC mechanism is not intended for use by other applications, set the
android:exported
attribute tofalse
in the component’s manifest element. -
If your IPC is accessible to other applications, you can apply a security policy by using the
<permission>
element. If IPC is between your own separate apps that are signed with the same key, it is preferable to use signature level permission in theandroid:protectionLevel
.
Intents
-
For activities and broadcast receivers, intents are the preferred mechanism for asynchronous IPC in Android. Depending on your application requirements, you might use sendBroadcast(), sendOrderedBroadcast(), or an explicit intent to a specific application component. For security purposes, explicit intents are preferred.
-
If you use an intent to bind to a Service, ensure that your app is secure by using an explicit intent. Using an implicit intent to start a service is a security hazard because you can’t be certain what service will respond to the intent, and the user can’t see which service starts.
-
Senders of an intent can verify that the recipient has permission by specifying a non-null permission with the method call. Only applications with that permission receive the intent. If data within a broadcast intent may be sensitive, you should consider applying a permission to make sure that malicious applications can’t register to receive those messages without appropriate permissions. In those circumstances, you may also consider invoking the receiver directly, rather than raising a broadcast.
Services
A Service is often used to supply functionality for other applications to use. Each service class must have a corresponding <service>
declaration in its manifest file.
-
By default, services are not exported and cannot be invoked by any other application. However, if you add any intent filters to the service declaration, it is exported by default. It’s best if you explicitly declare the
android:exported
attribute to be sure it behaves as you’d like. Services can also be protected using theandroid:permission attribute
. By doing so, other applications need to declare a corresponding<uses-permission>
element in their own manifest to be able to start, stop, or bind to the service. -
If your app targets Android 5.0 (API level 21) or later, you should use the JobScheduler to execute background services.
-
A service can protect individual IPC calls into it with permissions, by calling
checkCallingPermission()
before executing the implementation of that call. You should use the declarative permissions in the manifest, since those are less prone to oversight.
Binder and Messenger Interfaces
-
Using Binder or Messenger is the preferred mechanism for RPC-style IPC in Android. They provide a well-defined interface that enables mutual authentication of the endpoints, if required.
-
If you are providing an interface that does require access controls, use checkCallingPermission() to verify whether the caller has a required permission. This is especially important before accessing a service on behalf of the caller, as the identify of your application is passed to other interfaces.
Broadcast Receivers
-
A BroadcastReceiver handles asynchronous requests initiated by an Intent.
-
By default, receivers are exported and can be invoked by any other application. If your BroadcastReceiver is intended for use by other applications, you may want to apply security permissions to receivers using the
<receiver>
element within the application manifest. This prevents applications without appropriate permissions from sending an intent to the BroadcastReceiver.
Dynamically Loading Code
-
Loading code from outside of your application APK significantly increases the likelihood of application compromise due to code injection or code tampering.
-
If your application does dynamically load code, the most important thing to keep in mind about dynamically-loaded code is that it runs with the same security permissions as the application APK.
-
The major security risk associated with dynamically loading code is that the code needs to come from a verifiable source.
Security with HTTPS and SSL
This is a summary of the Android Developer Security with HTTPS and SSL Guide.
The Secure Sockets Layer (SSL)—now technically known as Transport Layer Security (TLS)—is a common building block for encrypted communications between clients and servers. It’s possible that an application might use SSL incorrectly such that malicious entities may be able to intercept an app’s data over the network.
As of Android 4.2 (Jelly Bean), Android currently contains over 100 CAs that are updated in each release. Similar to a server, a CA has a certificate and a private key. When issuing a certificate for a server, the CA signs the server certificate using its private key. The client can then verify that the server has a certificate issued by a CA known to the platform.
HTTPS Example
Assuming you have a web server with a certificate issued by a well known CA, you can make a secure request with code as simple this:
URL url = new URL("https://wikipedia.org");
URLConnection urlConnection = url.openConnection();
InputStream in = urlConnection.getInputStream();
copyInputStreamToOutputStream(in, System.out);
Suppose instead of receiving the content from getInputStream()
, it throws an exception:
javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.
This can happen for several reasons, including:
-
Unknown CA - The CA that issued the server certificate was unknown.
-
In this case, the
SSLHandshakeException
occurs because you have a CA that isn’t trusted by the system. It could be because you have a certificate from a new CA that isn’t yet trusted by Android or your app is running on an older version without the CA. More often a CA is unknown because it isn’t a public CA, but a private one issued by an organization such as a government, corporation, or education institution for their own use. With a custom TrustManager that knows about your CAs, the system is able to validate that your server certificate come from a trusted issuer.
-
-
Self-Signed Server Certificate - The server certificate wasn’t signed by a CA, but was self signed.
-
The second case of
SSLHandshakeException
is due to a self-signed certificate, which means the server is behaving as its own CA. As before, you can create your own TrustManager, this time trusting the server certificate directly.
-
-
Missing Intermediate CA - The server configuration is missing an intermediate CA.
-
The third case of
SSLHandshakeException
occurs due to a missing intermediate CA. Most public CAs don’t sign server certificates directly. Instead, they use their main CA certificate, referred to as the root CA, to sign intermediate CAs. They do this so the root CA can be stored offline to reduce risk of compromise. -
However, operating systems like Android typically trust only root CAs directly, which leaves a short gap of trust between the server certificate—signed by the intermediate CA—and the certificate verifier, which knows the root CA.
-
To solve this, the server doesn’t send the client only it’s certificate during the SSL handshake, but a chain of certificates from the server CA through any intermediates necessary to reach a trusted root CA.
-
There are two approaches to solve this issue:
-
Configure the server to include the intermediate CA in the server chain. Most CAs provide documentation on how to do this for all common web servers. This is the only approach if you need the site to work with default Android browsers at least through Android 4.2.
-
Or, treat the intermediate CA like any other unknown CA, and create a TrustManager to trust it directly, as done in the previous two sections.
-
-
Hostname verification
There are two key parts to verifying an SSL connection:
-
The first is to verify the certificate is from a trusted source, which was the focus of the previous section.
-
The second part is making sure the server you are talking to presents the right certificate. When it doesn’t, you’ll typically see an error like this:
java.io.IOException: Hostname 'example.com' was not verified
at libcore.net.http.HttpConnection.verifySecureSocketHostname(HttpConnection.java:223)
at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.connect(HttpsURLConnectionImpl.java:446)
-
One reason this can happen is due to a server configuration error. The server is configured with a certificate that does not have a subject or subject alternative name fields that match the server you are trying to reach. It is possible to have one certificate be used with many different servers.
Warnings About Using SSLSocket Directly
SSLSocket does not perform hostname verification. It is up the your app to do its own hostname verification, preferably by calling getDefaultHostnameVerifier()
with the expected hostname. Further beware that HostnameVerifier.verify()
doesn’t throw an exception on error but instead returns a boolean result that you must explicitly check.
Blacklisting
SSL relies heavily on CAs to issue certificates to only the properly verified owners of servers and domains. In rare cases, CAs are either tricked or breached, resulting in the certificates for a hostname to be issued to someone other than the owner of the server or domain.
In order to mitigate this risk, Android has the ability to blacklist certain certificates or even whole CAs. While this list was historically built into the operating system, starting in Android 4.2 this list can be remotely updated to deal with future compromises.
Pinning
An app can further protect itself from fraudulently issued certificates by a technique known as pinning. This prevents the compromise of one of the other 100+ CAs in the system from resulting in a breach of the apps secure channel.
Client Certificates
SSL also supports the notion of client certificates that allow the server to validate the identity of a client.
Nogotofail: A Network Traffic Security Testing Tool
-
Nogotofail is a tool gives you an easy way to confirm that your apps are safe against known TLS/SSL vulnerabilities and misconfigurations. It’s an automated, powerful, and scalable tool for testing network security issues on any device whose network traffic could be made to go through it.
Nogotofail is useful for three main use cases:
-
Finding bugs and vulnerabilities.
-
Verifying fixes and watching for regressions.
-
Understanding what applications and devices are generating what traffic.
Network Security Configuration
This is a summary of the Android Developer Network Security Configuration Guide.
Configuration
The Network Security Configuration feature lets apps customize their network security settings in a safe, declarative configuration file without modifying app code. These settings can be configured for specific domains and for a specific app. The key capabilities of this feature are as follows:
-
Custom trust anchors: Customize which Certificate Authorities (CA) are trusted for an app’s secure connections. For example, trusting particular self-signed certificates or restricting the set of public CAs that the app trusts.
-
Debug-only overrides: Safely debug secure connections in an app without added risk to the installed base.
-
Cleartext traffic opt-out: Protect apps from accidental usage of cleartext traffic.
-
Certificate pinning: Restrict an app’s secure connection to particular certificates.
The Network Security Configuration feature uses an XML file where you specify the settings for your app. You must include an entry in the manifest of your app to point to this file.
Example reference of the network security settings from the applications manifest xml:
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
<application android:networkSecurityConfig="@xml/network_security_config"
... >
...
</application>
</manifest>
Customizing Trusted CAs
An app may want to trust a custom set of CAs instead of the platform default. The most common reasons of this are:
-
Connecting to a host with a custom certificate authority, such as a CA that is self-signed or is issued internally within a company.
-
Limiting the set of CAs to only the CAs you trust instead of every pre-installed CA.
-
Trusting additional CAs not included in the system.
An app can customize its own connections using base-config
(for app-wide customization) or domain-config
(for per-domain customization).
For Configuring CA’s, configuration examples are available in the Android Documentation.
Opting Out of Cleartext Traffic
Applications intending to connect to destinations using only secure connections can opt-out of supporting cleartext (using the unencrypted HTTP protocol instead of HTTPS) to those destinations. This option helps prevent accidental regressions in apps due to changes in URLs provided by external sources such as backend servers.
For example, an app may want to ensure that all connections to secure.example.com are always done over HTTPS to protect sensitive traffic from hostile networks.
res/xml/network_security_config.xml:
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
<domain-config cleartextTrafficPermitted="false">
<domain includeSubdomains="true">secure.example.com</domain>
</domain-config>
</network-security-config>
Pinning Certificates
Normally, an app trusts all pre-installed CAs. If any of these CAs were to issue a fraudulent certificate, the app would be at risk from a man-in-the-middle attack. Some apps choose to limit the set of certificates they accept by either limiting the set of CAs they trust or by certificate pinning.
Certificate pinning is done by providing a set of certificates by hash of the public key (SubjectPublicKeyInfo of the X.509 certificate). A certificate chain is then valid only if the certificate chain contains at least one of the pinned public keys.
Note that, when using certificate pinning, you should always include a backup key so that if you are forced to switch to new keys or change CAs (when pinning to a CA certificate or an intermediate of that CA), your app’s connectivity is unaffected. Otherwise, you must push out an update to the app to restore connectivity.
res/xml/network_security_config.xml:
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
<domain-config>
<domain includeSubdomains="true">example.com</domain>
<pin-set expiration="2018-01-01">
<pin digest="SHA-256">7HIpactkIAq2Y49orFOOQKurWxmmSFZhBCoQYcRhJ3Y=</pin>
<!-- backup pin -->
<pin digest="SHA-256">fwza0LRMXouZHRC8Ei+4PyuldPDcf3UKgO/04cDM1oE=</pin>
</pin-set>
</domain-config>
</network-security-config>
Configuration Inheritance Behavior
Values not set in a specific configuration are inherited. This behavior allows more complex configurations while keeping the configuration file readable.
If a value is not set in a specific entry, then the value from the more general entry is used. For example, values not set in a domain-config are taken from the parent domain-config, if nested, or from the base-config if not. Values not set in the base-config use the platform default values.
For example, consider where all connections to subdomains of example.com must use a custom set of CAs. Additionally, cleartext traffic to these domains is permitted except when connecting to secure.example.com. By nesting the configuration for secure.example.com inside the configuration for example.com, the trust-anchors does not need to be duplicated.
Configuration File Format
The Network Security Configuration feature uses an XML file format. The overall structure of the file is shown in the following code sample:
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
<base-config>
<trust-anchors>
<certificates src="..."/>
...
</trust-anchors>
</base-config>
<domain-config>
<domain>android.com</domain>
...
<trust-anchors>
<certificates src="..."/>
...
</trust-anchors>
<pin-set>
<pin digest="...">...</pin>
...
</pin-set>
</domain-config>
...
<debug-overrides>
<trust-anchors>
<certificates src="..."/>
...
</trust-anchors>
</debug-overrides>
</network-security-config>
The full network security configuration options can be seen here.
SafetyNet
SafetyNet provides a set of services and APIs that help protect your app against security threats, including device tampering, bad URLs, potentially harmful apps, and fake users.
SafetyNet Attestation API
The SafetyNet Attestation API provides services for determining whether a device running your app satisfies Android compatibility tests.
SafetyNet examines software and hardware information on the device where your app is installed to create a profile of that device. The service then attempts to find this same profile within a list of device models that have passed Android compatibility testing. The API also uses this software and hardware information to help you assess the basic integrity of the device, as well as the APK information of the calling app. This attestation helps you to determine whether or not the particular device has been tampered with or otherwise modified.
SafetyNet Safe Browsing API
The SafetyNet Safe Browsing API provides services for determining whether a URL has been marked as a known threat by Google. Your app can use a URL check to determine whether a URL poses a known threat.
SafetyNet reCAPTCHA API
The SafetyNet reCAPTCHA API service includes a reCAPTCHA API that you can use to protect your app from malicious traffic. reCAPTCHA is a free service that uses an advanced risk analysis engine to protect your app from spam and other abusive actions. If the service suspects that the user interacting with your app might be a bot instead of a human, it serves a CAPTCHA that a human must solve before your app can continue executing.
SafetyNet Verify Apps API
The SafetyNet Verify Apps API allows your app to interact programmatically with the Verify Apps feature on a device, protecting the device against potentially harmful apps. The SafetyNet Verify Apps API allows you to leverage this feature to protect your app’s data. By using this API, you can determine whether a user’s device is protected by the Verify Apps feature, encourage users not already using the feature to opt in to its protection, and identify any known potentially harmful apps that are installed on the device.
Key Attestation
This is a summary of the Android Developer Key Attestation Security Guide and the Android 7.0: "Security Benefits that Truly Matter" post.
Verifying Hardware Backed Keypairs
Key Attestation will allow developers to make sure the keys they may be using in their apps are valid and stored in the phone’s hardware-backed keystore and not in software. When the attestation tool is given a generated alias for a key (the actual key should never be shared) it then generates a certificate chain that can be used to verify the key. Developers can verify both the key as well as the verified boot state to make sure everything is valid.
Phones that ship with Android N and use Google services will have a certificate that’s issued by Google as the root (or primary) authority while other phones that have been upgraded will need a certificate issued by the company who made them.
Not all phones that can run Android N have a trusted hardware environment to store encryption keys, and in those cases, software-level key attestation is used instead. The verified boot state can still be checked to make sure the system software hasn’t been tampered with.
Retrieving and Verifying a Hardware-backed Key Pair
During key attestation, you specify the alias of a key pair. The attestation tool, in return, provides a certificate chain, which you can use to verify the properties of that key pair.
If the device supports hardware-level key attestation, the root certificate within this chain is signed using an attestation root key, which the device manufacturer injects into the device’s hardware-backed keystore at the factory.
On devices that ship with hardware-level key attestation, Android 7.0 (API level 24), and Google Play services, the root certificate is signed with the Google attestation root key. You should verify that this root certificate appears within Google’s list of root certificates.
Implementing Key Attestation
-
Use a KeyStore object’s
getCertificateChain()
method to get a reference to the chain of X.509 certificates associated with the hardware-backed keystore. -
Check each certificate’s validity using a X509Certificate object’s
checkValidity()
method. Caution: Although you can complete this process within your app directly, it’s safer to check the certificates' revocation lists on a separate server that you trust. -
On a separate server that you trust, obtain a reference to the ASN.1 parser library that is most appropriate for your toolset. Use this parser to extract the attestation certificate extension data, which appears within the first element of the certificate chain.
-
The Key Attestation sample uses the ASN.1 parser from Bouncy Castle to extract an attestation certificate’s extension data. You can use this sample as a reference for creating your own parser.
-
-
Compare the extension data that you’ve retrieved from your ASN.1 parser with the set of values that you expect the hardware-backed key to contain. Caution: Although you can complete this process within your app directly, it’s safer to check the certificate’s extension data on a separate server that you trust.
Device Management Policies
It allows developers to create an application that manages access to its content by enforcing device management policies. Specifically, the application can be configured such that it ensures a screen-lock password of sufficient strength is set up before displaying restricted content to the user.
Define and Declare policy
-
Declare the policy in the
res/xml/device_admin.xml
file, example:<device-admin xmlns:android="http://schemas.android.com/apk/res/android"> <uses-policies> <limit-password /> </uses-policies> </device-admin>
-
Then reference it in the Android manifest file:
<receiver android:name=".Policy$PolicyAdmin" android:permission="android.permission.BIND_DEVICE_ADMIN"> <meta-data android:name="android.app.device_admin" android:resource="@xml/device_admin" /> <intent-filter> <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" /> </intent-filter> </receiver>
Create the Device Administration Receiver
The receiver will get notified of events related to the policies you’ve declared to support. An application can selectively override callback methods. For example:
public static class PolicyAdmin extends DeviceAdminReceiver {
@Override
public void onDisabled(Context context, Intent intent) {
// Called when the app is about to be deactivated as a device administrator.
// Deletes previously stored password policy.
super.onDisabled(context, intent);
SharedPreferences prefs = context.getSharedPreferences(APP_PREF, Activity.MODE_PRIVATE);
prefs.edit().clear().commit();
}
}
Activate the Device Administrator
Before enforcing any policies, the user needs to manually activate the application as a device administrator. It can be done like this:
if (!mPolicy.isAdminActive()) {
Intent activateDeviceAdminIntent =
new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
activateDeviceAdminIntent.putExtra(
DevicePolicyManager.EXTRA_DEVICE_ADMIN,
mPolicy.getPolicyAdmin());
// It is good practice to include the optional explanation text to
// explain to user why the application is requesting to be a device
// administrator. The system will display this message on the activation
// screen.
activateDeviceAdminIntent.putExtra(
DevicePolicyManager.EXTRA_ADD_EXPLANATION,
getResources().getString(R.string.device_admin_activation_message));
startActivityForResult(activateDeviceAdminIntent,
REQ_ACTIVATE_DEVICE_ADMIN);
}
Implement the Device Policy Controller
After the device administrator is activated successfully, the application then configures Device Policy Manager with the requested policy. For example:
-
Require password has minimum uppercase letters
DevicePolicyManager mDPM = (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE); ComponentName mPolicyAdmin = new ComponentName(context, PolicyAdmin.class); ... mDPM.setPasswordQuality(mPolicyAdmin, PASSWORD_QUALITY_VALUES[mPasswordQuality]); mDPM.setPasswordMinimumLength(mPolicyAdmin, mPasswordLength); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { mDPM.setPasswordMinimumUpperCase(mPolicyAdmin, mPasswordMinUpperCase); }
-
If the requirement is not met, invoke the activity to ask user to reset password:
if (!mDPM.isActivePasswordSufficient()) { ... // Triggers password change screen in Settings. Intent intent = new Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD); startActivity(intent); }
-
Finally, if requirement is met, the app can continue:
if (!mDPM.isAdminActive(..)) { // Activates device administrator. ... } else if (!mDPM.isActivePasswordSufficient()) { // Launches password set-up screen in Settings. ... } else { // Grants access to secure content. ... startActivity(new Intent(context, SecureActivity.class)); }
Supporting Direct Boot
Android 7.0 runs in a secure, Direct Boot mode when the device has been powered on but the user has not unlocked the device.
| Most apps should not use Direct Boot mode, as the apps will be running before user has unlocked the device. It should only be used if it’s important for the app to run right after the system is started. |
Requesting Access to Run During Direct Boot
Apps must register their components with the system before they can run during Direct Boot mode or access device encrypted storage. For example:
<receiver
android:directBootAware="true" >
...
<intent-filter>
<action android:name="android.intent.action.LOCKED_BOOT_COMPLETED" />
</intent-filter>
</receiver>
Accessing Device Encrypted Storage
The app will not be able to access the normal file system as the device is still locked. Android system provides two new storage locations for data:
-
Credential encrypted storage, which is the default storage location and only available after the user has unlocked the device.
-
Device encrypted storage, which is a storage location available both during Direct Boot mode and after the user has unlocked the device.
You can access device encrypted storage like this:
Context directBootContext = appContext.createDeviceProtectedStorageContext();
// Access appDataFilename that lives in device encrypted storage
FileInputStream inStream = directBootContext.openFileInput(appDataFilename);
// Use inStream to read content...
Getting Notified of User Unlock
When the user unlocks the device after restart, your app can switch to accessing credential encrypted storage and use regular system services that depend on user credentials.
To get notified when the user unlocks the device after a reboot, register a BroadcastReceiver from a running component to listen for unlock notification messages.
Migrating Existing Data
If a user updates their device to use Direct Boot mode, you might have existing data that needs to get migrated to device encrypted storage.
You can use:
-
Context.moveSharedPreferencesFrom()
-
Context.moveDatabaseFrom()
to migrate preference and database data between credential encrypted storage and device encrypted storage
Using Scoped Directory Access
This function make it easier for apps that just need access to specific directories. For example, photo apps only need to access the Pictures
directory.
This is a new function provided from Android 7.0
Accessing an External Storage Directory
Example:
StorageManager sm = (StorageManager)getSystemService(Context.STORAGE_SERVICE);
StorageVolume volume = sm.getPrimaryStorageVolume();
Intent intent = volume.createAccessIntent(Environment.DIRECTORY_PICTURES);
startActivityForResult(intent, request_code);
The system may confirm the access with the user.
Accessing a Directory on Removable Media
-
Add a BroadcastReceiver that listens for the MEDIA_MOUNTED notification, for example:
<receiver android:name=".MediaMountedReceiver" android:enabled="true" android:exported="true" > <intent-filter> <action android:name="android.intent.action.MEDIA_MOUNTED" /> <data android:scheme="file" /> </intent-filter> </receiver>
-
When the user mounts removable media, like an SD card, the system sends a MEDIA_MOUNTED notification. Request access like this:
// BroadcastReceiver has already cached the MEDIA_MOUNTED // notification Intent in mediaMountedIntent StorageVolume volume = (StorageVolume) mediaMountedIntent.getParcelableExtra(StorageVolume.EXTRA_STORAGE_VOLUME); volume.createAccessIntent(Environment.DIRECTORY_PICTURES); startActivityForResult(intent, request_code);


Course Meeting Times
Lectures: 2 sessions / week, 1.5 hours / session
A list of topics covered in the course is presented in the calendar.
Description
This introductory course gives an overview of many concepts, techniques, and algorithms in machine learning, beginning with topics such as classification and linear regression and ending up with more recent topics such as boosting, support vector machines, hidden Markov models, and Bayesian networks. The course will give the student the basic ideas and intuition behind modern machine learning methods as well as a bit more formal understanding of how, why, and when they work. The underlying theme in the course is statistical inference as it provides the foundation for most of the methods covered.
Problem Sets
There will be a total of 5 problem sets, due roughly every two weeks. The content of the problem sets will vary from theoretical questions to more applied problems. You are encouraged to collaborate with other students while solving the problems but you will have to turn in your own solutions. Copying will not be tolerated. If you collaborate, you must indicate all of your collaborators.
Each problem set will be graded by a group of students with the guidance of your TAs. Each problem set will be graded in a single grading session, usually on the first Monday after it is due, starting at 5pm. Every student is required to participate in one grading session. You should sign up for grading by contacting a TA, by email or in person; doing it early increases the chances of getting the preferred grading schedule. Students who do not register for grading by the third week of the course, will be assigned to a problem set by us.
If you drop the class after signing up for a grading session, please be sure to let us know so we can keep track of students available for grading. If you add the class during the term, please remember to sign up for grading.
Exams
There will be two in-class exams, a midterm midway through the term and a final the last day of class.
 The choice of the topic is up to you so long as it clearly pertains to the course material. To ensure that you are on the right track, you will have to submit a one paragraph description of your project a month before the project is due. Similarly to problem sets, you are encouraged to collaborate on the project. We expect a four page write-up about the project, which should clearly and succinctly describe the project goal, methods, and your results. Each group should submit only one copy of the write-up and include all the names of the group members (a two person group will have 6 pages, a three person group will have 8 pages, and so on). The projects will be graded on the basis of your understanding of the overall course material (not based on, e.g., how brilliantly your method works). The scope of the project is about 1-2 problem sets.
The projects are due in Lec #23. Electronic submission is required but we can accept only postscript or pdf documents. The short proposal should be turned in on or before Lec #12.
The projects can be literature reviews, theoretical derivations or analyses, applications of machine learning methods to problems you are interested in, or something else (to be discussed with course staff).
Grading
Your overall grade will be determined roughly as follows:
| ACTIVITIES | PERCENTAGES |
|---|---|
| Midterm | 15% |
| Problem sets | 30% |
| Final | 25% |
| Project | 30% |
Text
There are a number of useful texts for this course but each covers only some part of the class material.
Bishop, Christopher. Neural Networks for Pattern Recognition. New York, NY: Oxford University Press, 1995. ISBN:<PHONE_NUMBER>646.
Duda, Richard, Peter Hart, and David Stork. Pattern Classification. 2nd ed. New York, NY: Wiley-Interscience, 2000. ISBN:<PHONE_NUMBER>690.
Hastie, T., R. Tibshirani, and J. H. Friedman. The Elements of Statistical Learning: Data Mining, Inference and Prediction. New York, NY: Springer, 2001. ISBN:<PHONE_NUMBER>840.
MacKay, David. Information Theory, Inference, and Learning Algorithms. Cambridge, UK: Cambridge University Press, 2003. ISBN:<PHONE_NUMBER>989. Available on-line here.
Mitchell, Tom. Machine Learning. New York, NY: McGraw-Hill, 1997. ISBN:<PHONE_NUMBER>072.
You are responsible for the material covered in lectures (most of which will appear in lecture notes in some form), problem sets, as well as material specifically made available and indicated for this purpose. The weekly recitations/tutorials will be helpful in understanding the material and solving the homework problems.
Recommended Citation
For any use or distribution of these materials, please cite as follows:
Tommi Jaakkola, course materials for 6.867 Machine Learning, Fall 2006. MIT OpenCourseWare (http://ocw.mit.edu/), Massachusetts Institute of Technology. Downloaded on [DD Month YYYY].
Calendar
| LEC # | TOPICS | KEY DATES |
|---|---|---|
| 1 | Introduction, linear classification, perceptron update rule | |
| 2 | Perceptron convergence, generalization | |
| 3 | Maximum margin classification | |
| 4 | Classification errors, regularization, logistic regression | Problem set 1 out |
| 5 | Linear regression, estimator bias and variance, active learning | |
| 6 | Active learning (cont.), non-linear predictions, kernals | Problem set 1 due |
| 7 | Kernal regression, kernels | Problem set 2 out |
| 8 | Support vector machine (SVM) and kernels, kernel optimization | |
| 9 | Model selection | Problem set 2 due |
| 10 | Model selection criteria | |
| Midterm | ||
| 11 | Description length, feature selection | Problem set 3 out 3 days before Lec #11 |
| 12 | Combining classifiers, boosting | |
| 13 | Boosting, margin, and complexity |
Problem set 3 due Problem set 4 out |
| 14 | Margin and generalization, mixture models | |
| 15 | Mixtures and the expectation maximization (EM) algorithm | |
| 16 | EM, regularization, clustering | Problem set 4 due |
| 17 | Clustering | |
| 18 | Spectral clustering, Markov models | Problem set 5 out |
| 19 | Hidden Markov models (HMMs) | |
| 20 | HMMs (cont.) | |
| 21 | Bayesian networks | |
| 22 | Learning Bayesian networks | Problem set 5 due |
| 23 |
Probabilistic inference Guest lecture on collaborative filtering |
Projects due |
| Final | ||
| 24 | Current problems in machine learning, wrap up | Exams back |


| Issue # | Problem Name | Problem Description | Possible Solutions | Verified Solutions | Links |
| 1 | Can't push to GitHub because of large file which I already deleted | git filter-branch --index-filter 'git rm -r --cached --ignore-unmatch <file/dir>' HEAD | |||
| 2 | Git Clone "Filename too long" Error in Windows |
Follow the steps below to fix "Filename is too long" in
git. Update the git version to the latest from here. If you have updated, ignore this step. Navigate to your project folder Open the Git Bash and run as administrator To enable the long paths to run "git config core.longpaths true" in git bash Now clone the project that has long file names that should not produce such error now. This is a solution that works for all the times and no one reported after applying this solution. This works for all the repositories which will be clone in future projects. |
Filename too long - Solution 2 - Git specific project If you have clone already project into local machine and while getting new changes using the "git pull" command, it will produce the git filenames are too long error. To apply the fix only to this project, just go to the project home directory and find the ".git" folder. Open the config file and look at the [core] section. At the end of this section add longpaths to true as "longpaths = true". [core] ��� repositoryformatversion = 0 ��� filemode = false ��� bare = false ��� logallrefupdates = true ��� symlinks = false ��� ignorecase = true ��� longpaths = true This fix works only for this repo. |
https://www.javaprogramto.com/2020/04/git-filename-too-long.html | |
| 3 | |||||
| 4 | |||||
| 5 | |||||
| 6 | |||||
| 7 | |||||
| 8 | |||||
| 9 |


Get Identity
Forget Identity
Transfer
Contract
Multi
Test FC
Hook Transfer
Donate
Donate with Deep Link


The <javaMethod> element provides the name of the Java API method that you are describing and all the elements necessary to describe the method.
The <javaMethod> template requires an ID attribute as an anchor point. This ID is the target for references by the keyref attribute and for the internal applications that refer to that <javaMethod> element content. Use a unique key such as fully qualified class name (for example, com.ibm.xtools.ras.engine.tasks.IImportEngineTask) for the named API reference.
The <apiName>, <shortdesc> and the <javaMethodDetail> elements are required for this top-level container. The name of a method must differ from the name of all other non methods declared in the same class.
apiName, javaMethodDetail, no-topic-nesting, prolog, related-links, shortdesc
( (apiName) then (shortdesc) then (prolog) (optional) then (javaMethodDetail) then (related-links) (optional) then (no-topic-nesting) (any number))


The Easiest Way to Schedule Posts on Social Media
Spend less time posting & more time building relationships with your customers on social
Start Your Free 30-Day TrialSpend less time posting & more time building relationships with your customers on social
Start Your Free 30-Day TrialManage all of your company's social networks in one convenient dashboard, and get a bird's-eye view of what's happening in your social world.
Schedule content to automatically post at optimal times—so your social presence stays active, even when you’re not.
Hootsuite's Analytics and reports allow you to see what's working and what isn't. Learn about your audience and improve your campaigns.
Schedule unlimited messages across all your social networks.
Be a part of the conversation and never miss when people are talking about your brand.
Track your social media campaigns so you can improve ROI and grow your business.
Work as a team by assigning messages so they get to the right people in your business.
Two-step authentication ensures your brand and social networks are protected.
Track your brand, what customers are saying about you, and your competition.
Put all your profiles in one place, view performance across multiple networks, and easily measure results.
Automated post scheduling
Key performance metrics
Ad spend limit of $500 per month to boost posts
Team message assignments
Custom analytics
Exportable reports
Ad spend limit of $2,000 per month to boost posts


| Home | Trees | Index | Help |
|---|
| Package svnmailer :: Module settings :: Class GroupSettingsContainer |
|
object
--+ |Struct
--+ | GroupSettingsContainer
See Also: groupMembers
for the actual member list
| Method Summary | |
|---|---|
bool
|
compare some of the attributes |
list
|
Returns the list of member names that be ignored in comparisons |
Sets a key-value-pair for substitutions | |
| Inherited from Struct | |
Stub Initialization | |
Removes all references from private container | |
Object creation (Static method) | |
str
|
Representation for debugging purposes |
Set the self.name = value | |
| Inherited from object | |
x.__delattr__('name') <==> del x.name... | |
x.__getattribute__('name') <==> x.name... | |
x.__hash__() <==> hash(x)... | |
helper for pickle... | |
helper for pickle... | |
x.__setattr__('name', value) <==> x.name = value... | |
x.__str__() <==> str(x)... |
| Class Variable Summary | |
|---|---|
list |
__slots__ = ['cia_project_name', 'lock_subject_prefix', ...
|
NoneType |
_def_for_paths = None |
NoneType |
_def_for_repos = None |
ReadOnlyDict |
_dict_ = {'cia_project_name': None, 'lock_subject_prefix...
|
tuple |
_members_ = ('cia_project_name', 'lock_subject_prefix', ...
|
NoneType |
_name = None |
NoneType |
apply_charset_property = None |
NoneType |
bcc_addr = None |
NoneType |
browser_base_url = None |
NoneType |
cia_project_branch = None |
NoneType |
cia_project_module = None |
NoneType |
cia_project_name = None |
NoneType |
cia_project_path = None |
NoneType |
cia_project_submodule = None |
NoneType |
cia_rpc_server = None |
NoneType |
commit_subject_prefix = None |
NoneType |
commit_subject_template = None |
NoneType |
custom_header = None |
NoneType |
diff_command = None |
NoneType |
exclude_paths = None |
NoneType |
extract_x509_author = None |
NoneType |
for_paths = None |
NoneType |
for_repos = None |
NoneType |
from_addr = None |
NoneType |
generate_diffs = None |
NoneType |
ignore_if_other_matches = None |
NoneType |
lock_subject_prefix = None |
NoneType |
lock_subject_template = None |
NoneType |
long_mail_action = None |
NoneType |
long_news_action = None |
NoneType |
mail_transfer_encoding = None |
NoneType |
mail_type = None |
NoneType |
max_subject_length = None |
NoneType |
news_transfer_encoding = None |
NoneType |
propchange_subject_prefix = None |
NoneType |
propchange_subject_template = None |
NoneType |
reply_to_addr = None |
NoneType |
show_applied_charset = None |
NoneType |
show_nonmatching_paths = None |
NoneType |
to_addr = None |
NoneType |
to_fake = None |
NoneType |
to_newsgroup = None |
NoneType |
unlock_subject_prefix = None |
NoneType |
unlock_subject_template = None |
NoneType |
viewcvs_base_url = None |
| Inherited from Struct | |
NoneType |
_set_ = None |
| Instance Method Details |
|---|
_compare(self, other)compare some of the attributes
|
_getIgnorableMembers(self)Returns the list of member names that be ignored in comparisons This method called by_compare . Override this method to modify
the list.
|
| Class Variable Details |
|---|
_def_for_paths
|
_def_for_repos
|
_dict_
|
_members_
|
_name
|
apply_charset_property
|
bcc_addr
|
browser_base_url
|
cia_project_branch
|
cia_project_module
|
cia_project_name
|
cia_project_path
|
cia_project_submodule
|
cia_rpc_server
|
commit_subject_prefix
|
commit_subject_template
|
custom_header
|
diff_command
|
exclude_paths
|
extract_x509_author
|
for_paths
|
for_repos
|
from_addr
|
generate_diffs
|
ignore_if_other_matches
|
lock_subject_prefix
|
lock_subject_template
|
long_mail_action
|
long_news_action
|
mail_transfer_encoding
|
mail_type
|
max_subject_length
|
news_transfer_encoding
|
propchange_subject_prefix
|
propchange_subject_template
|
reply_to_addr
|
show_applied_charset
|
show_nonmatching_paths
|
to_addr
|
to_fake
|
to_newsgroup
|
unlock_subject_prefix
|
unlock_subject_template
|
viewcvs_base_url
|
| Home | Trees | Index | Help |
|---|
| Generated by Epydoc 2.1 on Mon Apr 17 12:39:11 2006 | http://epydoc.sf.net |


---
layout: post
title: VSCode Remote Debugging of Embedded Devices
date: '2017-05-09T18:44:00.000-07:00'
author: gojimmypi
tags:
modified_time: '2017-05-14T09:45:18.716-07:00'
thumbnail: https://4.bp.blogspot.com/-XuuPBq-e3kQ/WRJqlu8C47I/AAAAAAAAAaE/3EI2Ziq4sh4NdsLmojhQxbnynyzDe5qUgCLcB/s72-c/OpenOCD%2Bfor%2BVSCode.PNG
blogger_id: tag:blogger.com,1999:blog-4109066286647243251.post-6020087278731136553
blogger_orig_url: https://gojimmypi.blogspot.com/2017/05/vscode-remote-debugging-of-embedded.html
---
The developers for Visual Studio Code
continue to amaze me by implementing really awesome features. This latest feature is remote OpenOCD / GDB debugging!
As
mentioned in a previous post, I've been really enjoying the OpenDPS Programmable Power Supply project introduced by Johan
. This has been a really cool and fun learning opportunity.
Recently, I was able to get an
OpenOCD / GDB session running on Ubuntu to do single-step debugging
. If you've ever used gdb on a linux machine, even with the tui ... well, it is really cool, but when coming from the world of Visual Studio, there are a lot of cool IDE features missing.
I've tried
Visual Micro
and really like that environment. The drawback is that (at least at the time) there was no JTAG debugging. I noticed a recent update mentions that, so I need to revisit. Another drawback is that it is *very* Arduino specific. So embedded apps that use other libraries - say FreeRTOS - are practically impossible to load up, compile, and debug.
Another major player in the Visual Studio IDE world is the
SysProgs VisualGDB add-in app. It is a considerably more serious debugger supporting JTAG and more... alas there's *no* current or even planned Arduino library support. I really like the Arduino world. I have several ESP8266 and soon ESP32 projects that use Arduino-style code libraries. Adafruit in particular has a ton of really cool open source ESP8266 libraries and sample code
.
Enter VSCode. WOW! It supports gdb debugging! And shockingly easily!
First, make sure you have the
VSCode ms-vscode.cpptools add-in
installed.
Browse to the source code directory of your embedded app. In my case, I have my "Z:" drive mapped to a VM hosting Ubuntu (I have samba installed there).
{% include code_header.html %}
net use z: \\<IP_ADDRESS>\c$\
Z:/home/gojimmypi/workspace/opendps/opendps/
I had some initial difficulties as noted in issue 706 on gitthub, so be sure to take note of the forward slashes (not back-slashes!) when editing the file paths.{ "version": "0.2.0", "configurations": [ { "name": "Debug", "type": "cppdbg", "request": "launch", "miDebuggerPath": "C:/workspace/opendps/opendps/arm-none-eabi-gdb.exe", "targetArchitecture": "arm", "program": "Z:/home/gojimmypi/workspace/opendps/opendps/opendps.elf", "setupCommands": [ { "text": "file Z:/home/gojimmypi/workspace/opendps/opendps/opendps.elf" }, { "text": "target remote <IP_ADDRESS>:3333" }, { "text": "monitor reset init" } ], "externalConsole": false, "cwd": "Z:/home/gojimmypi/workspace/opendps/opendps/" } ] }
cd ~/workspace/opendps/openocd/scripts sudo openocd -f interface/stlink-v2.cfg -f target/stm32f1x.cfg
C:/Program Files (x86)/Atmel/Studio/7.0/toolchain/arm/arm-gnu-toolchain/bin/arm-none-eabi-gdb.exe


About Even Numbers
Show that the double of any natural number is even, then show that
the square of any even number is even too.
Show that every even natural number is the double of some natural number.
You must use the following definitions :
Require Import Arith.
Inductive even : nat -> Prop :=
| O_even : even 0
| plus_2_even : forall n:nat, even n -> even (S (S n)).
Hint Resolve O_even plus_2_even.
Fixpoint mult2 (n:nat) : nat :=
match n with
| O => 0
| S p => S (S (mult2 p))
end.
Solution
This file
Remarks and/or hints


Angular-Point-Example does not currently have an established employee recognition program. There are pockets of informal Branch/Section awards with limited visibility of recognition across the Division. In addition, it has been challenging to get nominations submitted into the command-level quarterly awards which are based upon very specific categories. Due to the reduced level of morale, we believe that establishing such a program would be greatly welcomed and appreciated by our team mates. With such a program, the leadership team also demonstrates commitment to the leadership practice of encouraging the heart.
Recently, the organization identified four aspirational values through the leadership challenge: excellence, teamwork, integrity, and innovation. An established award program supports values communication by recognizing personnel that demonstrate alignment to one or more of these values.
Develop and implement a program that recognizes employee contributions in alignment with organizational values and strategy with a focus on incentivizing positive behavior and organizational inclusion.


{% extends "base.html" %} {% block content %}
We encountered an error when trying to process your request.
Here are some recommended fixes:


The Great Quotes App is a web application that allows a user to add a quote that the user either thought of or got from someone else i.e. An author. The user posts the quote which can be read and voted upon by others or can even be deleted if the user wants to.
Posted: {{quote.completeDate|timeAgo}}


Class HeaderOutputConfig
The properties of this class control the output format of
SECSHeader
objects.
Inheritance
Namespace: com.CIMthetics.CSharpSECSTools.TextFormatter
Assembly: TextFormatter.dll
Syntax
public class HeaderOutputConfig
Properties
DisplayAsElementsOrAttributes
This property is pretty much only here to support "automatic" creation
from a json
file. It will ultimately set the DisplayAsType
property.
Declaration
public string DisplayAsElementsOrAttributes { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String | The only permissible value is "Elements" or "Attributes". |
DisplayAsType
This property controls how a SECSHeader
is displayed in the
case where a formatter is configured to output using XML.
Declaration
public DisplayAsType DisplayAsType { get; set; }
Property Value
| Type | Description |
|---|---|
| DisplayAsType | If this property's value is |
Remarks
This property's value has no effect if the output ends up being SML.
The default is to display as Attributes.
DisplayControlMessages
This property controls whether or not HSMS control messages are displayed in the output.
Declaration
public bool DisplayControlMessages { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean | If |
Remarks
The value of this property is used when the communication is going over an HSMS connection.
The default is false
.
DisplayDeviceId
This property controls whether or not the "Device Id" is displayed in the output.
Declaration
public bool DisplayDeviceId { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean | If |
Remarks
The default is false
.
DisplayMessageIdAsSxFy
This property controls how a SECSMessage
's stream and function
are displayed when the output format is XML.
Declaration
public bool DisplayMessageIdAsSxFy { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean | If |
Remarks
This property's value has no effect if the output ends up being SML.
The default is false
.
DisplaySystemBytes
This property controls whether or not the value of the "System Bytes" are displayed in the output.
Declaration
public bool DisplaySystemBytes { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean | If |
Remarks
The default is false
.
DisplayWBit
This property controls whether or not the value of the "W-bit" is displayed in the output.
Declaration
public bool DisplayWBit { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean | If |
Remarks
The value of this property is used when generating output in both SML and XML.
The default is true
.
Methods
ToString()
Creates a string
displaying the current "state" of this instance.
This is mostly only useful for debugging.
Declaration
public override string ToString()
Returns
| Type | Description |
|---|---|
| System.String |


From: Ahmed Williams Tel: 0027-72-5870-437 ATTN: SIR, PRIVATE AND HIGHLY CONFIDENTIAL Greeting! I know you will be surprised to read from me, but please this letter is a request from a family in dire need of assistance. I am Mr. Ahmed Williams from Angola. The first and the only son of Brigadier Chanza Williams communicating to you from Johannesburg, South Africa. I got your address from a business directory in Johannesburg Chamber of Commerce and Industry. And, I, on behalf of my widowed mother Mrs. Bridget Williams decided to solicit for your assistance to transfer the sum of US$35.8 Million (Thirty-five Million Eight Hundred Thousand United States Dollars), which he deposited in a safe box to private security company in Johannesburg, South Africa. In fact, my father said, and I quote: ?My son, I wish to draw your attention to US$35.8 Million (Thirty-five Million Eight Hundred Thousand United States Dollars). I deposited the box containing the fund in a security company in Johannesburg, South Africa as valuables. During the war, I was very committed and dedicated in winning the war against the rebels, until I found out that the senior army officers and government functionaries were busy helping themselves with government funds and properties, sending them to foreign countries. Due to this, when the former adviser to the president and I were assigned by the president (JOSE EDUARDO SANTOS) to purchase arms in South Africa, we saw this as a golden opportunity and diverted the money and share it, of which I got a total sum of US$35.8 Million (Thirty-five Million Eight Hundred Thousand United States Dollars). In case of my absence on earth as a result of death, only you should solicit for assistance of a reliable and sincere foreign partner to assist you to transfer this money out of South Africa for investment purpose. I deposited the box in your name and you can claim it alone with deposited code.   We are now living in South Africa as political asylum seekers. Financial laws and regulations of the Republic of South Africa do not permit us certain financial rights. In view of this, I cannot invest this fund in South Africa hence; I am seeking your assistance to transfer this fund out of South Africa for investment purpose. For your assistance, we are prepared to offer you 20% of the total fund while 10% will be set aside for any expenses incurred during this transaction. Please note that this transaction is 100% risk-free and the major thing I demand from you is to assure me the safety of this money when it finally gets to you. Further information and arrangement commence as soon as trust confidence and good relationship are established. I shall be most grateful if you maintain the confidentiality of this matter. Please, confirm your interest through the above contact Telephone number and send me a mail on<EMAIL_ADDRESS>. Best regards, AHMED WILLIAMS For the family. _________________________________________________________________ We've overhauled MSN Search Toolbar - FREE download! http://toolbar.msn.co.za?DI=1054&XAPID=2083


| Order Name | Order Time | Order Status | Flight | Daparture Time | Arrival Time | Flight Class | Amount | Select |
|---|
Our commitment, your pursuit.
${label}:
Home
Flights
Orders
Login
Logout
Account


|
SFML Game AI Demos
0.5.0
C++ intelligent agents for games, with demos using the SFML framework.
|
Base state class for entities in the game. A state defines an entity's current actions in the game. For example, an entity can be fleeing from another entity, or seeking an entity. More...
#include <BaseEntityState.hpp>
Public Member Functions | |
| BaseEntityState () | |
| Default constructor. More... | |
| BaseEntityState (std::string stateName) | |
| Overloaded constructor which takes a string parameter for the name of the state. More... | |
| ~BaseEntityState () | |
| Default destructor. More... | |
| virtual void | enter ()=0 |
| Pure virtual method to perform setup actions to enter a state. More... | |
| virtual void | update ()=0 |
| Pure virtual method to execute actions in a state. More... | |
| virtual void | exit ()=0 |
| Pure virtual method to perform cleanup actions and exit a state. More... | |
| virtual BaseEntityState * | getNewState ()=0 |
| Pure virtual method to return a pointer to a new state. More... | |
| std::string | getStateName () |
| Returns the state's name. More... | |
Private Attributes | |
| std::string | m_stateName |
| The name of the state. More... | |
Base state class for entities in the game. A state defines an entity's current actions in the game. For example, an entity can be fleeing from another entity, or seeking an entity.
|
inline |
Default constructor.
| GameAIDemos::BaseEntityState::BaseEntityState | ( | std::string | stateName | ) |
Overloaded constructor which takes a string parameter for the name of the state.
| stateName | The name of this state. |
|
inline |
Default destructor.
|
pure virtual |
Pure virtual method to perform setup actions to enter a state.
Implemented in GameAIDemos::IdleEntityState, GameAIDemos::FleeEntityState, GameAIDemos::SeekEntityState, and GameAIDemos::DeadEntityState.
|
pure virtual |
Pure virtual method to perform cleanup actions and exit a state.
Implemented in GameAIDemos::IdleEntityState, GameAIDemos::FleeEntityState, GameAIDemos::SeekEntityState, and GameAIDemos::DeadEntityState.
|
pure virtual |
Pure virtual method to return a pointer to a new state.
Implemented in GameAIDemos::FleeEntityState, GameAIDemos::IdleEntityState, GameAIDemos::SeekEntityState, and GameAIDemos::DeadEntityState.
| std::string GameAIDemos::BaseEntityState::getStateName | ( | ) |
Returns the state's name.
|
pure virtual |
Pure virtual method to execute actions in a state.
Implemented in GameAIDemos::IdleEntityState, GameAIDemos::FleeEntityState, GameAIDemos::SeekEntityState, and GameAIDemos::DeadEntityState.
|
private |
The name of the state.


Banks
IIT Roorkee has two banks to help students and staff make their transactions ease.And you can open an account on the opening day of the college.Also these banks give loans to the students to support their studies.
Hospital
Institute hospital IIT Roorkee is a 50 Beded hospital offering OPD , emergency and IPD , Laboratory , x-ray & ECG services to faculty , staffs and students . Ambulance services for referring patients to higher centres works in optimal.It also has online OPD booking system.
Places of worship
This is the temple inside the campus where the students can go and devote their feelings to the god.We celebrate all the religious festivals here.IIT Roorkee is a place where people of different faiths come together in learning. To ensure that all their religious customs are maintained, a number of places of worship are constructed on campus. A Temple dedicated to the Goddess Saraswati, near the football field in Saraswati Kunj, a Church near the main gate and a Mosque near Khosla International House, all dot the campus and add to its charm. Among the most peaceful places on campus, all these places of worship are the prime destination when all one wants to do is get away from it all.
Placement & Internship cell
The place where the dream of every student gets true.It heps and co-ordinates between the students and companies during placements.It has a great heritage and history of great records in placements.


Download - GoogleInputToolsHindi.exe
Google Hindi Input tool full Offline installer is here for Download.
This tool is for Hindi Typing with English Keyboard Just Like rajbhasha राजभाषा shree श्री Hindi हिंदी After download this file install with double click .If permission required by user account please permit. Installer will run TWO time with green going strip. After installation on toolbar english and hindi option (EN HI) displayed. Change language with Alt+Shift or by mouse (Windows 10 Windows key + spacebar). Now You can type Hindi with English Keyboard. Help video is also available
Complete below Verification to Download File
फाइल को डाउनलोड करने के लिए खाली बॉक्स क्लिक करें फिर Submit करें
Domains name, Hosting Provided By https://XISTO.COM
Cheap and Reliable services with TRUST & Honesty!


This place is to be determined. So lets talk about fishies. Fishies are awesome and they taste good too so thats a win-win. Kinda weird when you see the eyeballs tho.
This is the same as level 2 at the moment.This place is to be determined. So lets talk about fishies. Fishies are awesome and they taste good too so thats a win-win. Kinda weird when you see the eyeballs tho.


Recode with Table is responsible for recoding values of a dataset based on the specifications in variable_details.
rec_with_table( data, variables = NULL, database_name = NULL, variable_details = NULL, else_value = NA, append_to_data = FALSE, log = FALSE, notes = TRUE, var_labels = NULL, custom_function_path = NULL, attach_data_name = FALSE )
| data | A dataframe containing the variables to be recoded. Can also be a list of dataframes |
|---|---|
| variables | character vector containing variable names to recode or a variables csv containing additional variable info |
| database_name | String, the name of the dataset containing the variables to be recoded. Can also be a vector of strings if data is a list |
| variable_details | A dataframe containing the specifications (rules) for recoding. |
| else_value | Value (string, number, integer, logical or NA) that is used to replace any values that are outside the specified ranges (no rules for recoding). |
| append_to_data | Logical, if |
| log | Logical, if |
| notes | Logical, if |
| var_labels | labels vector to attach to variables in variables |
| custom_function_path | path to location of the function to load |
| attach_data_name | to attach name of database to end table |
a dataframe that is recoded according to rules in variable_details.
The variable_details dataframe needs the following variables to function:
name of new (mutated) variable that is recoded
type the variable is being recoded to cat = categorical, cont = continuous
name of dataframe with original variables to be recoded
name of variable to be recoded
variable type of start variable. cat = categorical or factor variable cont = continuous variable (real number or integer)
Value to recode to
Value/range being recoded from
Each row in variable_details comprises one category in a newly transformed variable. The rules for each category the new variable are a string in recFrom and value in recTo. These recode pairs are the same syntax as sjmisc::rec(), except in sjmisc::rec() the pairs are a string for the function attribute rec =, separated by '='. For example in rec_w_table variable_details$recFrom = 2; variable_details$recTo = 4 is the same as sjmisc::rec(rec = "2=4"). the pairs are obtained from the RecFrom and RecTo columns
each recode pair is row. see above example or PBC-variableDetails.csv
multiple old values that should be recoded into a new single value may be separated with comma, e.g. recFrom = "1,2"; recTo = 1
a value range is indicated by a colon, e.g. recFrom= "1:4"; recTo = 1 (recodes all values from 1 to 4 into 1)
for double vectors (with fractional part), all values within the specified range are recoded; e.g. recFrom = "1:2.5'; recTo = 1 recodes 1 to 2.5 into 1, but 2.55 would not be recoded (since it's not included in the specified range)
minimum and maximum values are indicates by min (or lo) and max (or hi), e.g. recFrom = "min:4"; recTo = 1 (recodes all values from minimum values of x to 4 into 1)
all other values, which have not been specified yet, are indicated by else, e.g. recFrom = "else"; recTo = NA (recode all other values (not specified in other rows) to "NA")
the "else"-token can be combined with copy, indicating that all remaining, not yet recoded values should stay the same (are copied from the original value), e.g. recFrom = "else"; recTo = "copy"
NA values are allowed both as old and new value, e.g. recFrom "NA"; recTo = 1. or "recFrom = "3:5"; recTo = "NA" (recodes all NA into 1, and all values from 3 to 5 into NA in the new variable)
library(cchsflow) bmi2001 <- rec_with_table( data = cchs2001_p, c( "HWTGHTM", "HWTGWTK", "HWTGBMI_der" ) )#>#>#>#>#>#> HWTGHTM HWTGWTK HWTGBMI_der #> 1 1.422 56.25 27.81784 #> 2 1.549 51.75 21.56788 #> 3 1.803 78.75 24.22474 #> 4 1.575 60.75 24.48980 #> 5 1.727 63.00 21.12301 #> 6 1.829 91.80 27.44197#>#>#>#>#> HWTGHTM HWTGWTK HWTGBMI_der #> 195 1.600 64.35 25.13672 #> 196 1.880 80.10 22.66297 #> 197 1.753 78.75 25.62635 #> 198 1.651 83.70 30.70657 #> 199 1.930 74.25 19.93342 #> 200 1.575 76.50 30.83900#> HWTGHTM HWTGWTK HWTGBMI_der #> 1 1.422 56.25 27.81784 #> 2 1.549 51.75 21.56788 #> 3 1.803 78.75 24.22474 #> 4 1.575 60.75 24.48980 #> 5 1.727 63.00 21.12301 #> 6 1.829 91.80 27.44197#> HWTGHTM HWTGWTK HWTGBMI_der #> 395 1.600 64.35 25.13672 #> 396 1.880 80.10 22.66297 #> 397 1.753 78.75 25.62635 #> 398 1.651 83.70 30.70657 #> 399 1.930 74.25 19.93342 #> 400 1.575 76.50 30.83900


To install wasm-pack, if you are running Unix,
run the following in your terminal, then follow the onscreen
instructions.
curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
If you are running Windows 64-bit,
download and run
wasm-pack-init.exe
then follow the onscreen instructions.
For all other platforms, run the following in your terminal:
cargo install wasm-pack


Strap-locks
Keep your guitar safe. Use strap-locks.
It’s a sad fact of life, but sometimes guitar straps don’t hang on quite as well to our babies as we would hope. Luckily for us, strap-locks exist and they are very easy to put on.
What you'll need
- Screwdriver
- Strap-locks
- Strap
Step 1 - Remove old strap buttons
Take off any strap that may be on the buttons. Using a screwdriver, unscrew the screw in the middle of each strap button. Place the strap buttons somewhere safe if you ever want them later.
Step 2 – Put on new strap-lock buttons
Doing the opposite of step 1, screw in the strap-lock buttons into the same holes as the old ones. If you have felt pads for the buttons, make sure to put those in between the guitar body and the buttons.
Step 3 – Put on strap attachments
This step will vary between brands, so it is best to check the instructions that come with the strap-locks. However, it normally involves placing part of the attachment through the hole in the strap and placing the other part on the other side of the strap, locking the attachment in place.
Step 4 – Attach the strap to the buttons
This will also depend on the brand but usually involves pressing a button on the strap attachment as you push it into the button.
You now have strap locks on your guitar!
Strap-locks Quiz - How much can you remember?
- Pry them off
- Unscrew them
- Use a strap to pull them off
- Dropping your guitar
- Theft of straps
- Peace of mind


In Order Details you can see form with Transactions
In left pane you can see list of transactions
In right pane you can see details of the selected in left pane transaction
At the end of the transaction details you can see messages provided by external systems (e.g. Paypal)
For a full list of Error codes please see "Messages provided by External Systems ( GICC )"


Add a new contact:
Contact name:
Phone number:
Email address:
Add to contacts
Address Book
Contact Information
Contact name:
Phone number:
Email:


[dscrdeql] <adriana> you guys overreacted about that
[dscrdeql] <Jellysmash> there's probably about a hundred rooms here that I've never even seen
[dscrdeql] <Jellysmash> or even dreamt of
[dscrdeql] <KQweci-Mod> Sounds good
[dscrdeql] <Jellysmash> one has the schematics for a time machine
[dscrdeql] <Jellysmash> cool
[dscrdeql] <Jellysmash> if only I can get to that level
[dscrdeql] <Jellysmash> one day
[dscrdeql] <KQweci-Mod> About how many in total do we have on here
[dscrdeql] <adriana> no point deleting my msg
[dscrdeql] <adriana> kinda rude
[dscrdeql] <Jellysmash> nah..we're all talking about it now
[dscrdeql] <adriana> when i was referencing our role
[dscrdeql] <AndronicusBass-Founder> I'm rarely in #off-topic
[dscrdeql] <KQweci-Mod> We have notice that
[dscrdeql] <KQweci-Mod> Its been a while since we last saw your 777 magic numbers
[dscrdeql] <KQweci-Mod>
GatewayBOT20-Aug-18 09:05 AM
[dscrdeql] <SwimedDragon> Lots of the new people are in #off-topic
[dscrdeql] <SwimedDragon> Probably because the rains happen there
[dscrdeql] <ghost> start:0.000000070 BTC
end:0.000000100 BTC
% change:+42.8571429%
price up
[dscrdeql] <Jonathan-Mod> I'm really struggling with their support right now, can't do a BTC/EQL trade
GatewayBOT20-Aug-18 09:18 AM
[dscrdeql] <SwimedDragon> Can you trade it at other pairs?
[dscrdeql] <AndronicusBass-Founder> Apparently they were planning to implement some updates and to withdrawl system, not sure where they're at with it but I wonder if something like that is going on right now.
GatewayBOT20-Aug-18 09:33 AM
[dscrdeql] <edsky>
[dscrdeql] <Jonathan-Mod> yeah their support said they'd have a fix in 24 hour 36 hours ago, I know they know what the problem is and I gave them very low level details on how to reproduce the issue.....It's ok I'm sure they're working on it
[dscrdeql] <edsky> How is everyone
[dscrdeql] <edsky> I ready for a beer
[dscrdeql] <Jonathan-Mod> Great, about to crash for a few hours - how are you? @edsky
[dscrdeql] <edsky> Are you still awake lol definitely part owl
[dscrdeql] <edsky> It must be daybreak now lol
[dscrdeql] <miles> morning @edsky - punchy for a monday
[dscrdeql] <miles> not beer time yet here
[dscrdeql] <edsky> Haha just hit 7:43 pm here I’ll have a beer for you @miles
[dscrdeql] <miles> the global round!!
[dscrdeql] <miles> just never stops
[dscrdeql] <miles> virtual beer
[dscrdeql] <Jonathan-Mod> Dang, you in Australia? @edsky
[dscrdeql] <edsky> Yep
[dscrdeql] <edsky> Left new york when i was 9
[dscrdeql] <Jonathan-Mod> Nice
[dscrdeql] <Jellysmash> @Jonathan-Mod i think exrates have changed their support people
[dscrdeql] <Jellysmash> 2 weeks ago it was really good and the people there coudl comprehend english well.
[dscrdeql] <Jellysmash> On Friday last week when I tried to 'talk' to support there it was virtually useless
[dscrdeql] <Jellysmash> the person either didn't know basic english or was too dumbwitted to comprehend the most simple thing
[dscrdeql] <Jellysmash> I just gave up in frustration
[dscrdeql] <Combat Wombat> that doesn't sound good
[dscrdeql] <Jellysmash> after wasting an hour of my time
[dscrdeql] <Combat Wombat> was hoping they would improve not get worse
[dscrdeql] <Jellysmash> I think they must have started off with a good crew and maybe swapped them out with retards
[dscrdeql] <Jellysmash> or maybe I just happen to get the dud that day


Welcome to ScalaTion, the Scala-based system for Simulation, Optimization and Analytics.
This system, coded in Scala, supports multi-paradigm simulation modeling including 'tableau', 'event', 'process', 'dynamics', 'dynamics_pde', 'activity' and 'state' oriented models.
Scala is a modern object-oriented, functional programming language that is well-suited for developing simulation engines. It is in the Java family of languages and can call Java code. The inclusion of advanced and functional programming capabilities, makes the code much more concise than Java. ScalaTion also supports optimization and analytics as they nowadays go hand-in-hand with simulation modeling. Some of the algorithms come in both sequential and parallel versions.
The ScalaTion 1.3 version defines multiple .par subpackages that contain parallel versions of sequential algorithms. Future directions include completing the 'scala3d' and 'physics' packages.
As of version 1.3, ScalaTion consists of three subprojects: scalation_mathstat, scalation_modeling and sclation_models.
Please read the LICENSE file (an MIT style license).
$ tar xvfz scalation_1.3.tar.gz
OR
$ unzip scalation_1.3.zip
$ cd scalation_1.3
$ cd scalation_models
$ sbt
> compile
> run-main apps.process.Bank
> run-main scalation.analytics.RegressionTest
> exit
ScalaTion 1.3 is set up to use the Simple Build Tool sbt.
ScalaTion 1.3 uses the following build specification files build.sbt, build.sbt and build.sbt. Source packages are in the src/main/scala directory, class files are in the target/scala-2.12/classes directory, and documentation files are in the target/scala-2.12/api directory. Data file input, output or analytics are stored in subdirectories of data, while database files are stored in store.
To develop using an IDE:
For more information about the source code, see
src/README_src.hmtl.
Overall scaladoc generated API for ScalaTion
Papers/Documentation
Online supplement
Source Packages (doc)
Package
Description
~/scalation_1.3/target/scala-2.12/api
MATH AND STAT
scalation.util
A package of utilities needed by the other packages.
- scalation.util.bld
A subpackage of for building util implementations.
scalation.scala2d
A package supporting 2D graphics based on Java 2D.
scalation.math
A package of mathematical objects and operations needed for analytics, simulation and optimization.
scalation.linalgebra
A package of implementations for linear algebra (e.g., for vectors and matrices).
Vectors and matrices of real (Double), rational and complex numbers are supported.
- scalation.linalgebra.bld
A subpackage for building implementations for linear algebra (e.g., for vectors and matrices).
- scalation.linalgebra.gen
A subpackage of generic implementations for linear algebra (e.g., for vectors and matrices).
Vectors and matrices of types implementing Numeric can be instantiated.
- scalation.linalgebra.mem_mapped
A subpackage for memory mapped linear algebra (e.g., for vectors and matrices).
- - scalation.linalgebra.mem_mapped.bld
A sub-subpackage for building implementations for memory mapped linear algebra (e.g., for vectors and matrices).
- scalation.linalgebra.par
A subpackage of parallel implementations for linear algebra.
scalation.relalgebra
A package of implementations for columnar relational algebra.
scalation.plot
A package for displaying basic plots and histograms.
scalation.random
A package for random numbers and random variates (Normal distribution, etc.)
scalation.stat
A package of statistical objects and operations needed for simulation,
including implementations for summary statitistics and ANOVA.
MODELING
scalation.model
A package defining the general form of a model.
scalation.scala3d
A package supporting 3D graphics based on JavaFX 3D (Under development).
scalation.animation
A package supplying a general purpose animation engine.
scalation.calculus
A package for computing derivatives, gradients and Jacobians.
scalation.minima
A package supporting simulation optimization (minimization).
scalation.maxima
A package supporting simulation optimization (maximization).
scalation.analytics
A package supporting analytics, including regression, time series analysis and clustering.
- scalation.analytics.par
A subpackage supporting parallel analytics, including regression, time series analysis and clustering.
- scalation.analytics.classifier
A subpackage supporting analytics, including several types of classifier.
-- scalation.analytics.classifier.par
A subpackage supporting parallel analytics, including several types of classifier.
scalation.graphalytics
A package supporting graph analytics, including shortest path, subgraph isomorphism, etc.
scalation.graphalytics.mutable
A package supporting graph analytics, including shortest path, subgraph isomorphism, etc. using mutable graphs.
scalation.queueingnet
A package supporting queueing network models.
scalation.tableau
A simulation engine for tableau oriented (spreedsheet like) models.
scalation.event
A simulation engine for event oriented models such as Event Scheduling or Event Graphs.
scalation.process
A simulation engine for process oriented models such as Process-Interaction Models.
scalation.dynamics
A simulation engine for systems dynamics (continuous simulation), which includes
general-purpose Ordinary Differential Equation (ODE) solvers.
scalation.dynamics_pde
A simulation engine for systems dynamics (continuous simulation), which includes
category-specific Partial Differential Equation (PDE) solvers.
scalation.physics
A physics engine for simulation based games (Under development).
scalation.activity
A simulation engine for activity oriented models such as Petri Nets.
scalation.state
A simulation engine for state oriented models such as Markov Chains.
APPLICATIONS
apps.activity
Example models for activity oriented models such as Petri Nets.
apps.analytics
Example analytics problems.
apps.dynamics
Example models for systems dynamics (continuous simulation).
apps.event
Example models for event oriented models such as Event Graphs.
apps.game
Example simulation-oriented games.
apps.montecarlo
Example Monte Carlo simulation.
apps.optimization
Example optimization problems.
apps.process
Example models for process oriented models such as Process-Interaction Models.
apps.simopt
Example simulation optimization problems.
apps.state
Example models for state oriented models such as Markov Chains.
apps.tableau
Example models for tableau oriented (spreadheet like) models.
Source Packages (src)
Package
Description
MATH AND STAT MODULE
scalation.util
A package of utilities needed by other packages.
- scalation.util.bld
A subpackage of for building util implementations.
scalation.scala2d
A package supporting 2D graphics based on Java 2D.
scalation.math
A package of mathematical objects and operations needed for analytics, simulation and optimization.
scalation.linalgebra
A package of implementations for linear algebra (e.g., for vectors and matrices).
Vectors and matrices of real (Double) and complex numbers are supported.
- scalation.linalgebra.bld
A subpackage for building implementations for linear algebra (e.g., for vectors and matrices).
- scalation.linalgebra.gen
A subpackage of generic implementations for linear algebra (e.g., for vectors and matrices).
Vectors and matrices of types implementing Numeric can be instantiated.
- scalation.linalgebra.mem_mapped
A subpackage for memory mapped linear algebra (e.g., for vectors and matrices).
- - scalation.linalgebra.mem_mapped.bld
A sub-subpackage for building implementations for memory mapped linear algebra (e.g., for vectors and matrices).
- scalation.linalgebra.par
A subpackage of parallel implementations for linear algebra.
scalation.relalgebra
A package of implementations for columnar relational algebra.
scalation.plot
A package for displaying basic plots and histograms.
scalation.random
A package for random numbers and random variates (Normal distribution, etc.)
scalation.stat
A package of statistical objects and operations needed for simulation,
including implementations for summary statitistics and ANOVA.
MODELING MODULE
scalation.model
A package defining the general form of a model.
scalation.scala3d
A package supporting 3D graphics based on JavaFX 3D (Under development).
scalation.animation
A package supplying a general purpose animation engine.
scalation.calculus
A package for computing derivatives, gradients and Jacobians.
scalation.minima
A package supporting simulation optimization (minimization).
scalation.maxima
A package supporting simulation optimization (maximization).
scalation.analytics
A package supporting analytics, including regression, time series analysis and clustering.
- scalation.analytics.par
A subpackage supporting parallel analytics, including regression, time series analysis and clustering.
- scalation.analytics.classifier
A subpackage supporting analytics, including several types of classifiers.
-- scalation.analytics.classifier.par
A subpackage supporting parallel analytics, including several types of classifiers.
scalation.graphalytics
A package supporting graph analytics, including shotest path, subgraph isomorphism, etc.
scalation.graphalytics.mutable
A package supporting graph analytics, including shotest path, subgraph isomorphism, etc. using mutable graphs.
scalation.queueingnet
A package supporting queueing network models.
scalation.tableau
A simulation engine for tableau oriented (spreedsheet like) models.
scalation.event
A simulation engine for event oriented models such as Event Scheduling or Event Graphs.
scalation.process
A simulation engine for process oriented models such as Process-Interaction Models.
scalation.dynamics
A simulation engine for systems dynamics (continuous simulation), which includes
general-purpose Ordinary Differential Equation (ODE) solvers.
scalation.dynamics_pde
A simulation engine for systems dynamics (continuous simulation), which includes
category-specific Partial Differential Equation (PDE) solvers.
scalation.physics
A physics engine for simulation based games (Under development).
scalation.activity
A simulation engine for activity oriented models such as Petri Nets.
scalation.state
A simulation engine for state oriented models such as Markov Chains.
APPLICATIONS
apps.activity
Example models for activity oriented models such as Petri Nets.
apps.analytics
Example analytics problems.
apps.dynamics
Example models for systems dynamics (continuous simulation).
apps.event
Example models for event oriented models such as Event Graphs.
apps.game
Example simulation-oriented games.
apps.montecarlo
Example Monte Carlo simulation.
apps.optimization
Example optimization problems.
apps.process
Example models for process oriented models such as Process-Interaction Models.
apps.simopt
Example simulation optimization problems.
apps.state
Example models for state oriented models such as Markov Chains.
apps.tableau
Example models for tableau oriented (spreadheet like) models.
UNIT TESTS
testing.util
Tests for package of utilities needed by other packages.
testing.scala2d
Tests for package supporting 2D graphics based on Java 2D.
testing.math
Tests for package of mathematical objects and operations needed for analytics, simulation and optimization.
testing.linalgebra
Tests for package of implementations for linear algebra (e.g., for vectors and matrices).
Vectors and matrices of real (Double) and complex numbers are supported.
testing.relalgebra
Tests for package of implementations for columnar relational algebra.
testing.plot
Tests for package for displaying basic plots and histograms.
testing.random
Tests for package for random numbers and random variates (Normal distribution, etc.)
testing.stat
Tests for package of statistical objects and operations needed for simulation,
including implementations for summary statitistics and ANOVA.
Code Release Process
Similarly for scalation_modeling and scalation_models.
Currently the .jar files need to be copied (copy_jars.sh) into the lib directory of dependent subprojects.
$ cd scalation_1.3
$ cd scalation_mathstat
$ sbt
> compile
> package
> test
> run-main scalation.util.RunSpellCheck 'package-directory'
> run-main scalation.GenIndexHtml
> clean
> doc
> exit


--- layout: "frontpage" title: "hlilje | Hampus Liljekvist" description: "The official website of Hampus Liljekvist" ---


Public JSON files
- committee-info.json
- Committee (PMC) names and membership (docs)
- committee-retired.json
- Summary details of retired committees (docs)
- icla-info.json
- Names of people who have submitted ICLAs who have uids (committer accounts) (docs)
- icla-info_noid.json
- Names of people who have submitted ICLAs who don't (yet) have uids (committer accounts) (docs)
- member-info.json
- ASF Member id listing (docs)
- pods-scan.json
- Current status of Incubator podling websites relating to required navigation links (docs)
- public_ldap_authgroups.json
- Membership of LDAP auth groups. Membership of an LDAP auth group is used to grant commit karma for sub-project and other resources (docs)
- public_ldap_groups.json
- Membership of the remaining LDAP unix groups (apsite, committers and member). (docs)
- public_ldap_people.json
- Basic details of LDAP personal entries. Shows the public name and whether the login is currently disabled (docs)
- public_ldap_projects.json
- Details of PMCs and Podlings. The 'owners' list holds the ids with (P)PMC karma, and the 'members' list holds the ids with (P)PMC committer karma. (docs)
- public_ldap_roles.json
- Membership of LDAP role groups. For example committers shows the list of people with committer karma (docs)
- public_ldap_services.json
- Membership of LDAP service groups. For example pmc_chairs shows the list of people with PMC chair karma (docs)
- public_nonldap_groups.json
- Membership of auth groups not defined in LDAP. (this file is likely to become obsolete) (docs)
- public_podling_status.json
- Current Incubation status of each podling (docs)
- public_podlings.json
- Listings of podling data TODO? (docs)
- site-scan.json
- Current status of project websites relating to required navigation links (docs)
For more information see API docs
and the public JSON generator scripts.


Tabs
Choose what tabs are shown in the top bar:
OS
Network
Battery
Speedtest
Theme
Choose what theme the app is displayed in:
Light Theme
Dark Theme (Coming soon...)
Developer Options
Enable Developer Options
Toggle Dev Console
Show Debug Page
Are you sure?
×
Enabling Developer Options will allow you to make changes directly to this app while its running. You should only enable these features if you know what you are doing.