ME 351: Fluid Mechanics
Physical properties of fluids and fundamental concepts in fluid mechanics. Hydrostatics. Conservation laws for mass, momentum and energy. Flow similarity and dimensional analysis as applied to engineering problems in fluid mechanics. Laminar and turbulent flow. Engineering applications such as flow measurement, flow in pipes and fluid forces on moving bodies.
MTE 322: Electromechanical Machine Design
Integrated design of mechanical motion transmission systems: gearing, couplings, bearings, power screws, fasteners, and their integration; sensing and measurement of mechanical motion; specification and selection of motors and electromechanical actuators; analysis and design of controllers for motion transmission systems; case studies.
MTE 360: Automatic Control Systems
Feedback control design and analysis for linear dynamic systems with emphasis on mechanical engineering applications; transient and frequency response; stability; system performance; control modes; state space techniques; Introduction to digital control systems.
MTE 380: Mechatronics Engineering Design Workshop
Most of the term is devoted to a significant design project in which student groups work independently and competitively, applying the design process to a project goal set by the faculty coordinator. The design project typically includes construction of an electro-mechanical prototype, and part of the course grade may depend on the performance of the prototype in a competitive test. (Our group placed top 5)
MSCI 261: Engineering Economics
Review of Vectors and Vector Operations; 3-D Analytic Geometry and Space Curves; Multivariable Calculus, including Partial Differentiation, Total Differential, Chain Rule, Directional Derivative, Gradient Operator, Maxima and Minima; Multiple Integrals - Surface Area, Volume and Moments of Inertia; Line and Surface Integrals; Vector Theorems; Complex Analysis including Limits, Analytic Functions, Complex Line Integral, Cauchy's Integral Formula; Fourier Series (real and complex) and Fourier Integrals.
MTE 203: Advanced Calculus
Review of Vectors and Vector Operations; 3-D Analytic Geometry and Space Curves; Multivariable Calculus, including Partial Differentiation, Total Differential, Chain Rule, Directional Derivative, Gradient Operator, Maxima and Minima; Multiple Integrals - Surface Area, Volume and Moments of Inertia; Line and Surface Integrals; Vector Theorems; Complex Analysis including Limits, Analytic Functions, Complex Line Integral, Cauchy's Integral Formula; Fourier Series (real and complex) and Fourier Integrals.
MTE 204: Numerical Methods
Number Systems and Machine Errors; Roots of Non-Linear Equations; Matrix Calculations; Eigenvalue and Eigenvector Calculations; Interpolation and Approximation; Numerical Integration and Solution of ODE's (linear and non-linear) and systems of ODEs; Calculation of Series; Solution Methods for PDE's; Use of numeric and symbolic computing tools.
MTE 220: Sensor and Insturmentation
Input-output relationships, transfer functions and frequency response of linear systems; operational amplifier circuits using feedback, diodes, analog signal detection, conditioning and conversion systems; transducers and sensors, difference and instrumentation amplifiers, and active filters.
MTE 241: Real Time Systems & Computer Structures
Introduction to computer organization, basic real-time concepts, process management, interprocess communication and synchronization, memory management, resource management, interrupt handling, concurrent programming, file systems.
MTE 309: Introduction to Thermodynamics and Heat Transfer
Macroscopic approach to energy analysis. Energy transfer as work and heat, and the First Law of thermodynamics. Properties and states of simple substances. Control-mass and control-volume analysis. The essence of entropy, and the Second Law of thermodynamics. The Carnot cycle and its implications for practical cyclic devices. Introduction to heat transfer by conduction, convection, and radiation. Basic formulation and solution of steady and transient problems. Issues relevant to the cooling of electrical devices.
MTE 320: Actuators and Power Electronics
Review of circuit analysis & basic electromagnetic theory. Power electronics: power electronics circuits, H bridges, PWM control, interfacing, power amplifiers. DC servo & stepper motors, AC synchronous & induction motors. Transformers. Introduction to typical speed and torque control techniques of motors
MTE 321: Design and Dynamics of Machines
Principles of the geometry and motion in linkages and mechanisms. Computer-aided kinematic and kinetic analysis of mechanisms. Synthesis of mechanisms. Static failure and yield criteria in ductile and brittle materials. Fatigue failure criteria due to fluctuating stresses. Shaft design under static and fluctuating loads.
MTE 325: Microprocessor Systems and Interfacing for Mechatronics Engineering
Synchronization and data flow; interfacing to sensors and actuators; microprocessor system architecture, parallel, serial, and analog interfacing; buses; direct memory access (DMA); interfacing considerations.
MTE 219: Mechanics of Deformable Solids
An introduction to mechanical response of materials and stress-strain relationships. Behaviour of members in stresses and strain with corresponding loading types. A cummulative project of this course was designing, prototyping, and analyzing a truss given several constraints with the goal of maximizing the ratio of mass loaded to mass of truss. Tools used include Solidworks, AutoCAD, Lasercutter, powertools, etc.
MTE 241: Computer Structures and RTOS
Computer organization, basic real-time concepts, process management, interprocess communication and synchronization, memory management, resource management, interrupt handling, concurrent programming, file systems.
MTE 220: Sensors and Intrumentation
Circuit theory; input-output relationships, transfer functions and frequency response of linear systems; operational amplifier circuits using negative or positive feedback;operational amplifier circuits using diodes; analog signal detection, conditioning and conversion systems; transducers and sensors, difference and instrumentation amplifiers, active filters.
MTE 262: Microprocessors and Digital Logic
Number systems, logic gates, Boolean algebra. Karnaugh maps and combinational logic design. Implementation of combinational logic circuits on Field Programmable Gate Arrays (FPGA) boards. Sequential logic and state machines. Programmable Logic Controllers (PLCs) and PLC programming using ladder logic and statement list. Microcomputer structure and operation, I/O, and interfacing and interrupts. Assembly language programming. Laboratory work includes microcomputer and PLC programming.
MTE 140: Algorithms and Data Structures
This course provided deep insight into software design Data Structures, abstract data types, recursive, and iterative Algorithms, including sorting, searching, and hashing. Labs involved using complex data structures and algorithms for solving real world problems.
MTE 111: Structure and Properties of Materials
This course detailed the fundamental principles of material properties, such as the relationships between macroscopic material properties and microscopic causes. Including lab work with various materials to identify said properties using a variety of testing equipment used in industry to perform metallurgic analysis.
MTE 121: Digital Computation
This course was an introduction to electronic digital computers, and the basics of programming in C++ and RobotC. Topics ranged from pointer basics and polymorphism.
MTE 120: Circuits
This course discussed Basic electromagnetic theory, first and second order circuits, physically building and analyizng AC/DC circuits; elements; first-order transient response and AC/DC circuit analysis. Labs included using a variety of tools to test and measure the circuits built. The course gave an insight into solving circuits through rudimentary processes.
MTE 201: Experimental Measurement & Statistical Analysis
This is a thorough statistics course that describes the fundamentals of measurement methods and analysis. There was an end of course project that involved creating an intricate device/system to take measurements of various measurands.
MTE 202: Ordinary Differential Equations
This math course develops methods for solving several types of ODE's through a plethura of methods. Example problems including Laplace transforms of second order circuits. This course entailed a project that required handwritten methods and MATLAB for graphical representations of the final solutions.
MTE 100: Mechatronics Engineering Intro
This course detailed design process, project planning, as well as an indepth look into GD&T through 2D and 3D Software designs such as AutoCAD and Solidworks
SYDE 182: Physics 2 (Dynamics)
Kinematics of particles, rectilinear and curvilinear motion. Kinetics of particles, application to space mechanics. Energy and momentum methods. Systems of particles. Kinematics and kinetics of rigid bodies; planar motion. Vibrations.
MTE 203: Advanced Calculus
Multivariable Calculus, including Partial Differentiation, Total Differential, Chain Rule, Directional Derivative, Gradient Operator, Maxima and Minima; Multiple Integrals - Surface Area, Volume and Moments of Inertia; Line and Surface Integrals; Vector Theorems; Complex Analysis including Limits, Analytic Functions, Complex Line Integral, Cauchy's Integral Formula; Fourier Series (real and complex) and Fourier Integrals.
MTE 204: Numerical Methods
Number Systems and Machine Errors; Roots of Non-Linear Equations; Matrix Calculations; Eigenvalue and Eigenvector Calculations; Interpolation and Approximation; Numerical Integration and Solution of ODE's (linear and non-linear) and systems of ODEs; Calculation of Series; Solution Methods for PDE's; Use of numeric and symbolic computing tools.


{% extends 'layouts/base.html' %} {% block title %} GMU Bookshare • About {% endblock %} {% block content %}
The purpose of Bookshare is to allow Mason students to safely and securely coordinate textbook exchanges.
Have an old textbook? Bookshare will help you find an incoming student who wants to buy it from you.
Bookshare is only open to current students and faculty at George Mason University with active NETIDs.
This exclusivity provides a safe, closed community within which users can exchange their textbooks.
Members of the Student-Run Computing and Technology group at George Mason University are the clever, talented students behind Bookshare.
We are a group of creative people that like making software and wanted to give back to the Mason community at the same time.
Contact us to get involved!


For you, Digital Ocean. (App Platform won't detect this repo as a static site without this file, but it's not actually used in the site.)


WITNESS LIST Jurisprudence Committee April 7, 1997-9:00A SB 179 For: Chapa, Jorge (U.T.), Austin On: Brown, Don (TX Higher Ed. Crdg Brd), Austin Registering, but not testifying: For: Romero, Jesse (MALDEF), San Antonio On: Hunter, Teri (Office of AG), Austin SB 409 For: Clark, Diana (League of Women Voters), Austin Jackson Lee, Sheila (18th Congressional Dist), Washington, DC Johnson, Eddie Bernice (30th Congressional Dist), Washington, D On: Mauzy, Oscar (self), Austin SB 416 For: Almaguer, Geerie (self), Austin Reed, E. Richard (self), Dallas On: Shelton, David (TX Father's Alliance), Venus Registering, but not testifying: On: Bedard, Judge Theo (330th District Court), Dallas Vega, Jorge (Office of AG), Austin SB 502 For: Freeman, Bill (JPCAT), Gainesville Registering, but not testifying: For: Allison, Jim (CJCAT), Austin Ott, Judge Patricia (self), West Sjoberg, Elizabeth (Texas Hospital Assoc.), Austin Welsh, Dinah S. (Texas Hospital Assoc.), Austin Williams, Judge John (JPCAT), West SB 620 Registering, but not testifying: For: Jones, Jerry Frank (State Bar of Texas), Austin SB 621 For: Christian, George (Txns for Judicial Refrm), Austin Kelly, Hugh Rice (Self & TJR), Houston Kruse, Kristin (self), Houston Martin, John (TX Assoc of Defense Csl), Austin Mundt, Courtney (self), Houston Wood, Judge Sharolyn (self), Houston On: Mauzy, Oscar (self), Austin Registering, but not testifying: For: Lilly, Susan (TX Civil Justice League), Austin Tryan, Bill (TX Civil Justice League), Austin White, Michael L. (TABCC), Austin SB 628 For: Clark, Diana (League of Women Voters), Austin Korbel, George (self), Austin Romero, Jesse (MALDEF), San Antonio On: Mauzy, Oscar (self), Austin SB 692 Against: Hammill-Reh, Hope (City of Houston), Houston SB 743 Registering, but not testifying: For: Rodriguez, Amador R. (Cameron Co Juv Probate), Brownsville SB 774 On: Cuellar, Robert (TDOC), Austin SB 825 For: McDonald, Dottie (TX Assoc for Court Adm.), Houston Wilson, Diane (Cnty Clerk Leg. Cte.), Richmond Wolbrueck, Bonnie (Cnty Dist Courts Assoc.), Georgetown Registering, but not testifying: For: Groomer, Cindy (Cnty & Dist Clerks Assn), Amarillo McCorkle, Judge Lamar (133rd District Court), Houston Wessels, Bob (Harris Cty Crim Crts), Houston SB 883 For: Sullivan, Craig (Self), Arlington SB 885 For: Greenlee, Dave (TX Buss Law Foundation), Ft. Worth Knepp, Christopher A. (TX Employment Law Counc), Austin SB 948 For: Cornett, Ray M. (Tax Assess. Coll. Assn.), Angleton Against: Cole, Sheryl N. (Tx Municipal League), Austin SB 1007 On: Perkins, Pamela (Office of AG), Austin Registering, but not testifying: On: Perkins, Jr., Thomas P. (Office of AG), Austin SB 1098 For: Hickson, Elizabeth J. (self & Victoria Barnett), Austin Ingalls, Ronald E. (self), Austin SB 1161 For: Bedard, Theo Judge (Dallas Dist. Judges), Dallas Hahn, Linda (Dist Ct Admin. Dallas), Dallas Against: Shelton, David (Texas Fathers Alliance), Austin SB 1180 For: Miller, James O. (S.A. Police Officers), San Antonio Registering, but not testifying: For: King, Carl E. (S.A. Police Officers), San Antonio SB 1184 For: Arnot, Ch. Justice Bud (Judicial Conduct Cmn), Eastland Flowers, Robert (Judicial Conduct Cmn.), Austin Lawrence, Judge Tom (State Cmn on Jud. Con.), Humble Registering, but not testifying: For: HIle, Richard (TX Trial Lawyers Assn.), Austin O'Neal, Michael L. (Judicial Conduct Cmn.), Dallas SB 1304 For: Bacarisse, Charles (Harris Cnty Dist Clerk), Houston Hynson, Kathy (self), Richmond Walbrueck, Bonnie (Cnty & Dist Clerks Assn), Georgetown Registering, but not testifying: For: Groomer, Cindy (Cnty & Dist Clerks Assn), Amarillo Rodriguez-Mendoza, Amal (self), Austin Wilson, Diane (Cnty Clerk Leg. Cte.), Richmond SB 1417 For: McCorkle, Judge Lamar (133rd District Court), Houston Phillips, Ch. Just. Tom (self), Austin Wessels, Bob (Cnty Courts at Law), Houston West, David (TX Assn of State Judges), Austin Against: Horton, Susan (TX Municipal League), Austin On: Benedict, Jerry (Office of Court Admin.), Austin Rybacki, Douglas (Office of Court Admin.), Austin Registering, but not testifying: For: Freeman, Bill (JPCAT), Gainesville McDonald, Dottie (self), Houston O'Neal, Michael (TX Mun. Courts Assoc.), Dallas Ott, Judge Patricia (JPCAT), West Williams, Judge John (JPCAT), West SB 1528 On: Herskowitz, Robin (State Comptroller), Austin Registering, but not testifying: Against: Lain, Jackie (TX Assoc. of School Bds), Austin SB 1530 Registering, but not testifying: For: Christian, Jr., Floyd (self), Angleton Cornett, Ray M. (self), Angleton SB 1556 On: Key, Alicia (Office of Atty General), Austin Registering, but not testifying: For: Almaguer, Gerrie (Firt American Bank TX), Bryan Against: Shelton, David (Texas Fathers Alliance), Austin SB 1614 For: Davis, Johnnie F. (self), Austin Wood, Larry G. (self), Ft. Worth Against: Morris, Mark (TX Commerce Bank), Austin Neeley, Karen (IBAT), Austin Schneider, Robert (Consumers Union), Austin Temple, Larry (TX Mortgage Bkrs Assoc.), Austin Registering, but not testifying: For: Hile, Richard (TX Trial Lawyers Assoc.), Austin Against: Sandberg, Eric (TSCBA), Austin On: Patterson, Michael H. (Pierson & Patterson), Arlington SB 1818 For: Hilbig, Steve (Bexar Cnty Cr Dist Atty), San Antonio SB 1864 Registering, but not testifying: For: Chamberlin, Roland (homeowner associations), Houston Neimann, Larry (TCAI and CCUCA), Austin SJR 23 For: Jackson Lee, Sheila (18th Congressional Dist), Washington, DC Johnson, Eddie Bernice (30th Congressional Dist), Washington, D SJR 25 For: Christian, George (TJER), Austin Kelly, Hugh Rice (self & TJER), Houston Kruse, Kristin (self), Houston Martin, John (TX Assoc of Defense Csl), Austin Mundt, Courtney (self), Houston Phillips, Judge Tom (self), Austin Wood, Judge Sharolyn (TJR), Houston Registering, but not testifying: For: White, Michael (TABCC), Austin SJR 30 Against: Cole, Sheryl N. (Tx Municipal League), Austin


LunchR
lunchR
is smallish group of people, having lunch, talking R,
data, stats, whatevs.
Upcoming
- 2019-03-19 noon @ Pine State Biscuits on SE Division
Past
- 2019-01-03 noon @ Teote
- 2018-12-04 noon @ Marukin Ramen
- 2018-11-07 noon @ Elephants Delicatessen
- 2018-09-18 noon @ Laughing Planet
- 2018-10-10 noon @ MOD Pizza
- 2018-08-14 noon @ Riyadh’s Lebanese Restaurant
- 2018-07-18 noon @ Boke Bowl
- 2018-06-07 noon @ Director’s Park
- 2018-05-08 noon @ Elephants Delicatessen
- 2018-04-19 noon @ Pine Street Market
- 2018-03-06 noon @ Mi Mero Mole
- 2018-02-05 noon @ Bambuza
- 2017-12-05 noon @ Kalé
- 2017-10-25 noon @ Laughing Planet Cafe
- 2017-09-28 noon @ Tangier Restaurant
- 2017-08-23 noon @ Mi Mero Mole


I am a passionate industrial design student with a strong interest for developing sustainable design solutions. As a dynamic and motivated design student, I had a chance to participate in different teamworks in relation to improve my skills. It's a pleasure to meet with you!


Released between 1982 and 1984
The ATARI 1200XL was released with 64Ko of memory in 1982. Only available in the United States and deemed a commercial failure, it was quickly removed from the market and replaced by the 600XL/800XL combo. No PBI. NTSC only.
The ATARI 600XL was ATARI Inc.'s most affordable system. Released in 1983, it came with 16Ko of RAM (expandable to 64Ko) and was released both in the United States and in Europe where it was a strong seller. PBI. NTSC / PAL.
The ATARI 800XL was ATARI Inc.'s strongest seller and a replacement to the $1200XL. At $300 less than the 1200XL, it offered the same functionalities plus a parallel interface. Released in 1983 with 64Ko of memory. Strongest seller of the 8-bit line. PBI. NTSC / PAL / SECAM
The ATARI 1400XL included 64Ko of RAM, a speech synthetizer, a built-in modem and the new memory management chip, FREDDIE. PBI. NTSC only. Prototype. Unreleased
In addition of the 1400XL features, the ATARI 1450XLD included a parallel disk drive controller and a 360K double density disk drive. PBI. NTSC only. Prototype. Unreleased.
The ATARI 1600XL was to be a groundbreaking hybrid system with 2 modes: IBM PC compatible (Intel 8088 CPU) and the classic ATARI 8-Bit chipset (6502 et al.). Developed with TOSHIBA. Prototype. Unreleased.


A music festival app for two questions
Where are my friends at?
By checking into sets and rating them, you can share where
you're at and whats going on without spending forever sending messages.
Who should I see next?
Several views of the festival schedule make it easier to
pick where to go next.
Research Artists
Your ratings for each artist shown on the schedule.
All Festivals
The notes you make will be available next month and next year.
Keep track of your friends
See which set your friends are at on the schedule


QDesktopServices Class
The QDesktopServices class provides methods for accessing common desktop services. More...
| Header: | #include <QDesktopServices> |
| qmake: | QT += gui |
| Since: | Qt 4.2 |
Static Public Members
| bool | openUrl(const QUrl &url) |
| void | setUrlHandler(const QString &scheme, QObject *receiver, const char *method) |
| void | unsetUrlHandler(const QString &scheme) |
Detailed Description
The QDesktopServices class provides methods for accessing common desktop services.
Many desktop environments provide services that can be used by applications to perform common tasks, such as opening a web page, in a way that is both consistent and takes into account the user's application preferences.
This class contains functions that provide simple interfaces to these services that indicate whether they succeeded or failed.
The openUrl() function is used to open files located at arbitrary URLs in external applications. For URLs that correspond to resources on the local filing system (where the URL scheme is "file"), a suitable application will be used to open the file; otherwise, a web browser will be used to fetch and display the file.
The user's desktop settings control whether certain executable file types are opened for browsing, or if they are executed instead. Some desktop environments are configured to prevent users from executing files obtained from non-local URLs, or to ask the user's permission before doing so.
URL Handlers
The behavior of the openUrl() function can be customized for individual URL schemes to allow applications to override the default handling behavior for certain types of URLs.
The dispatch mechanism allows only one custom handler to be used for each URL scheme; this is set using the setUrlHandler() function. Each handler is implemented as a slot which accepts only a single QUrl argument.
The existing handlers for each scheme can be removed with the unsetUrlHandler() function. This returns the handling behavior for the given scheme to the default behavior.
This system makes it easy to implement a help system, for example. Help could be provided in labels and text browsers using help://myapplication/mytopic URLs, and by registering a handler it becomes possible to display the help text inside the application:
class MyHelpHandler : public QObject { Q_OBJECT public: ... public slots: void showHelp(const QUrl &url); }; QDesktopServices::setUrlHandler("help", helpInstance, "showHelp");
If inside the handler you decide that you can't open the requested URL, you can just call QDesktopServices::openUrl() again with the same argument, and it will try to open the URL using the appropriate mechanism for the user's desktop environment.
Note: Since Qt 5, storageLocation() and displayName() are replaced by functionality provided by the QStandardPaths class.
See also QSystemTrayIcon, QProcess, and QStandardPaths.
Member Function Documentation
[static]
bool QDesktopServices::openUrl(const QUrl &url)
Opens the given url in the appropriate Web browser for the user's desktop environment, and returns true
if successful; otherwise returns false
.
If the URL is a reference to a local file (i.e., the URL scheme is "file") then it will be opened with a suitable application instead of a Web browser.
The following example opens a file on the Windows file system residing on a path that contains spaces:
QDesktopServices::openUrl(QUrl("file:///C:/Documents and Settings/All Users/Desktop", QUrl::TolerantMode));
If a mailto
URL is specified, the user's e-mail client will be used to open a composer window containing the options specified in the URL, similar to the way mailto
links are handled by a Web browser.
For example, the following URL contains a recipient<EMAIL_ADDRESS>), a subject (Test
), and a message body (Just a test
):
mailto:user@foo.com?subject=Test&body=Just a test
Warning: Although many e-mail clients can send attachments and are Unicode-aware, the user may have configured their client without these features. Also, certain e-mail clients (e.g., Lotus Notes) have problems with long URLs.
Warning: A return value of true
indicates that the application has successfully requested the operating system to open the URL in an external application. The external application may still fail to launch or fail to open the requested URL. This result will not be reported back to the application.
See also setUrlHandler().
[static]
void QDesktopServices::setUrlHandler(const QString &scheme, QObject *receiver, const char *method)
Sets the handler for the given scheme to be the handler method provided by the receiver object.
This function provides a way to customize the behavior of openUrl(). If openUrl() is called with a URL with the specified scheme then the given method on the receiver object is called instead of QDesktopServices launching an external application.
The provided method must be implemented as a slot that only accepts a single QUrl argument.
If setUrlHandler() is used to set a new handler for a scheme which already has a handler, the existing handler is simply replaced with the new one. Since QDesktopServices does not take ownership of handlers, no objects are deleted when a handler is replaced.
Note that the handler will always be called from within the same thread that calls QDesktopServices::openUrl().
See also openUrl() and unsetUrlHandler().
[static]
void QDesktopServices::unsetUrlHandler(const QString &scheme)
Removes a previously set URL handler for the specified scheme.
See also setUrlHandler().


compiled from github.com/github/gitignore
Custom
.db
.sqlite
OSX
.DS_Store .AppleDouble .LSOverride
# Icon must end with two


GZON
version 1.0.0
A simple JavaScript lib to compress, decompress and optimize json data exchange with GZIP and Base64. This library try to reduce object size by replacing keys with smaller ones. Thus, an object with a lot of different keys that never repeat will be harder to compressed efficiently. It could even increase the size of the result for small object


lingvo.core.early_stop module¶
Early stopping based on dev-set performance.
-
class
lingvo.core.early_stop.
MetricHistory
(params)[source]¶ Bases:
object
Record given metric versus global_step history to a file.
-
static
SetLogdirInMetricHistories
(params, logdir)[source]¶ Set the logdir member in all MetricHistory.params objects in params.
Parameters: - params – global model params.
- logdir – root dir for current run.
Needs to be called by trainer once the logdir is known, but before MetricHistory objects are constructed.
-
_metric_histories_map
= {}¶
-
hist_file
¶
-
minimize
¶
-
static
-
class
lingvo.core.early_stop.
EarlyStop
(params)[source]¶ Bases:
object
Early stopping based on dev-set performance.
Factors out the steps needed to perform early stopping in the trainer when a selected metric hasn’t improved for a given number of steps. If the window param is 0 this is guaranteed to be a no-op.
-
metric_history
¶
-
best_step
¶
-
last_step
¶
-
FProp
(theta)[source]¶ Creates an op to determine the best step from the metric history file.
Parameters: theta – Not currently used. Returns: The created op. This uses BestStepOp rather than reading the file directly from python in order to ensure compatibility with DevBasedSchedule for learning-rate decay. It is natural to use dev-based decay and early stopping together, for example decaying when dev-set perplexity hasn’t improved for n steps, and stopping when it hasn’t improved for 3n steps.
-


101
I Will Walk with Integrity
A PSALM OF DAVID.
1 I will sing of steadfast love and justice;
to you, O LORD, I will make music.
2 I will ponder the way that is blameless.
Oh when will you come to me?
I will walk with integrity of heart
within my house;
3 I will not set before my eyes
anything that is worthless.

Whoever has a haughty look and an arrogant heart
I will not endure.
6 I will look with favor on the faithful in the land,
that they may dwell with me;
he who walks in the way that is blameless
shall minister to me.
7 No one who practices deceit
shall dwell in my house;
no one who utters lies
shall continue before my eyes.
8 Morning by morning I will destroy
all the wicked in the land,
cutting off all the evildoers
from the city of the LORD.


Triggered after the components are initialized (eg: After the constructor of each component is executed)
but before their state is set from the hash portion of the URL (e.g., http://mysearchinterface#q=myQuery
).
This is also before the first query is launched (if the SearchInterface.options.autoTriggerQuery is true
).
The string value is afterComponentsInitialization
.
Triggered right after the UI is fully initialized.
Concretely this means that the constructor of each component has been executed, and that the state coming for the URL (e.g., http://mysearchinterface#q=myquery
) has been applied.
It is triggered before the first query is launched, and if the SearchInterface.options.autoTriggerQuery is true
.
The string value is afterInitialization
.
This event is triggered right before each components inside the search interface get initialized (eg: Before the constructor of each component is executed).
The string value is beforeInitialization
.
This is triggered when the UI needs to be dynamically removed so that components can unbind any internal handlers they might have set globally on the window or the document.
After this event has been executed, the search interface can be dynamically removed and all handlers can be considered cleanly removed.
The string value is nuke
.
Triggered right before the state from the URL (e.g., http://mysearchinterface#q=myQuery
) gets applied in the interface.
This will typically only be useful if the SearchInterface.options.enableHistory is set to true
.
The string value is restoreHistoryState
.
This static class is there to contain the different string definitions for all the events related to initialization.
Note that these events will only be triggered when the init function is called.
This means these events are normally called only once when the search interface is initialized.


Brave Entertainment's new boy group DKB introduces member D1 with a hip dance teaser film
by beansssBrave Entertainment's upcoming new boy group DKB would like to introduce member #2 - D1!
Born on February 15, 1998, D1 is in charge of dance, acrobatics, as well as vocals in DKB. He also boasts a wide range of special skills, like song writing, choreographing, and soccer.
Check out a glimpse of D1's fancy footwork in his hip, trendy dance introduction film, above!


Top Question
Qsub disregarded memory limit
Modified 1 min ago P8ul
| 7 | 6 | 13 |
| Votes | Answers | Views |
Javascript rotates element => trying to set..
Modified 1 min ago P8ul
| 0 | 6 | 13 |
| Votes | Answers | Views |


Loving Care Pet Boarding - Selection Practice
Alex Childers - CS 328
Sign In
Username:
Password:
Validate by pasting .xhtml copy's URL into
https://html5.validator.nu/


Want more creativity support using this technique?
Our Centre for Creativity in Professional Practice has extensive expertise in designing and delivering creativity workshops for customers. Based on Bright Sparks we can:
- Tailor creative personas to fit your needs and stakeholders
- Develop a full creative process using preferred personas to work within your constraints
- Combine Bright Sparks with other creativity techniques and tools
- Provide experienced facilitators to run creativity workshops.
For more information, advice and quotes, contact us at:
If you have any comments or queries regarding the technical aspects of this website, please contact:


Version: (loading) Change to: Execution environment does not connect to any node, everyhing is local and in memory only. tx.origin =
tx.origin =


Rush of Libraries and Frameworks
Architechting your app by choosing best of design pattern.
Source : Addy Osmani
var counter = (function() {
var privateCounter = 0;
function changeBy(val) {
privateCounter += val;
}
return {
increment: function() {
changeBy(1);
},
decrement: function() {
changeBy(-1);
},
value: function() {
return privateCounter;
}
};
})();
console.log(counter.value()); // logs 0
counter.increment();
counter.increment();
console.log(counter.value()); // logs 2
counter.decrement();
console.log(counter.value()); // logs 1
// IIFE - imidiate invoking function expression
(function () {
// ... all vars and functions are in this scope only
// still maintains access to all globals
}());
(function ($, CSLib) {
// now have access to globals jQuery (as $) and CSLib in this code
}(jQuery, CSLib));
// you can write any plugin or jquery plugin in this way.
(function($) {
// jQuery plugin code here
})(jQuery);
Sometimes you don’t just want to use globals, but you want to declare them. We can easily do this by exporting them, using the anonymous function’s return value. Doing so will complete the basic module pattern, so here’s a complete example:
var MODULE = (function () {
var my = {},
privateVariable = 1;
function privateMethod() {
// ...
}
my.moduleProperty = 1;
my.moduleMethod = function () {
// ...
};
return my;
}());
Problems when splitting code in multiple files
var MODULE = (function (my) {
my.anotherMethod = function () {
// added method...
};
return my;
}(MODULE));
Our module will have gained a new public method named MODULE.anotherMethod. This augmentation file will also maintain its own private internal state and imports.
Flexible Multipart Module
var MODULE = (function (my) {
// add capabilities...
return my;
}(MODULE || {}));
In this pattern, the var statement is always necessary. Note that the import will create the module if it does not already exist.
var MODULE = (function (my) {
var old_moduleMethod = my.moduleMethod;
my.moduleMethod = function () {
// method override, has access to old through old_moduleMethod...
};
return my;
}(MODULE));
//File: calc.js
var CalcModule = (function($, pub){ //jQuery will still be available via $
var mem = new Array(); //private variable
pub.storeInMemory = function(val){
mem.push(val);
};
pub.retrieveFromMemory = function(){
return mem.pop();
};
return pub;
})(jQuery, CalcModule || {});
//File: calc_functions.js
var CalcModule = (function($, pub){
pub.add = function(a,b){
var result = a + b;
pub.storeInMemory(result);
return result;
};
pub.sub = function(a,b){
var result = a - b;
pub.storeInMemory(result);
return result;
};
return pub;
}(jQuery, CalcModule || {}));
var CalcModule = (function(){
var mem = new Array(); //private variable
var storeInMemory = function(val) { //private function
mem.push(val);
};
var add = function(a, b) {
var result = a + b;
storeInMemory(result); //call to private function
return result;
};
var sub = function(a, b) {
var result = a - b;
storeInMemory(result); //call to private function
return result;
};
var retrieveFromMemory = function() {
return mem.pop();
};
return {
add: add,
sub: sub,
popMemory: retrieveFromMemory
};
})();
(function($) {
$.CSCom_Nav = function(options) {
if ( typeof(options) == "undefined" || options == null ) { options = {}; };
var cS = {
options: $.extend({
menu: '#menu',
panel: 'body',
trigger: '.menu-trigger',
closeOnContentClick: true,
duration: 150,
easing: 'ease-in-out',
before: function(){ },
after: function(){ }
},options),
init : function() { ....},
openMenu: function() {....},
menu: '#CSCom_Nav-menu',
panel: '.CSCom_Nav-panel',
setStyle: function( ) { … }
};
return {
on: cS.init,
trigger: cS.triggerMenu,
open: cS.openMenu,
close: cS.closeMenu,
someComplexMethod: function( ) { … }
};
};
})(jQuery);
var sideNav = $.CSCom_Nav({
menu: '#sidenav',
trigger: '.menu-trigger',
duration: 300
…
});
sideNav.on( );
Ext.define('Person',
{
name : 'ABCD',
constructor : function(name){
if(name){
this.name = name;
}
},
getName : function(){
alert("My name is " + this.name);
}
});
Ext.define('Student',
{
extend : 'Person',
schoolName : 'ABCD',
constructor : function(name, schoolName){
this.schoolName = schoolName || 'ABCD';
//call parent class constructor
this.callParent(arguments);
},
getSchoolName : function(){
alert("My school name is " + this.schoolName);
}
});
var newStudent = new Student('XYZ', 'ABC School');
newStudent.getName(); //output: XYZ
newStudent.getSchoolName(); //output: ABC School
Ext.define('TutorialApp.view.login.Login', {
extend: 'Ext.window.Window',
xtype: 'login',
requires: [
'TutorialApp.view.login.LoginController',
'Ext.form.Panel'
],
controller: 'login',
bodyPadding: 10,
title: 'Login Window',
closable: false,
autoShow: true
});
"The problem with object-oriented languages is they’ve got all this implicit environment that they carry around with them. You wanted a banana but what you got was a gorilla holding the banana... and the entire jungle". by Joe Armstrong, creator of Erlang
There are some use cases where we need to use Object Oriented style for e.g Libraries , Framework
Product development will bring constraint in OO style due to tight coupling of Components
MVC is not completely suitable for client side architecture , Unidirectional method is prefered
Global mutation, changes environment , create side effects
Testing is difficult for interconnected Objects
Lets explore Pure functional ways...
Pure functions take some input and return some output based on that input. They are the simplest reusable building blocks of code in a program. Perhaps the most important design principle in computer science is KISS (Keep It Simple, Stupid).
// impure
var minimum = 21;
var checkAge = function(age) {
return age >= minimum;
};
// pure
var checkAge = function(age) {
var minimum = 21;
return age >= minimum;
};
Pure functions are completely independent of outside state, and as such, they are immune to entire classes of bugs that have to do with shared mutable state.
JavaScript arguments are passed by reference, which means that if a function were to mutate a property on an object or array parameter that would mutate state that is accessible outside the function. Pure functions must not mutate external state.
Finally, we can run any pure function in parallel since it does not need access to shared memory and it cannot, by definition, have a race condition due to some side effect.
This is very much possible in a server side js environment with threads as well as in the browser with web workers though current culture seems to avoid it due to complexity when dealing with impure functions
// Impure function
function mouseOnLeftSide(mouseX) {
return mouseX < window.innerWidth / 2;
}
document.onmousemove = function(e) {
console.log(mouseOnLeftSide(e.pageX));
};
//Pure Function
function mouseOnLeftSide(mouseX, windowWidth) {
return mouseX < windowWidth / 2;
}
document.onmousemove = function(e) {
console.log(mouseOnLeftSide(e.pageX, window.innerWidth));
};
mouseOnLeftSide(5, 499) // ensure it works with width < 500
// Impure - accessing document global directly
var getHTML = function(id) {
var el = document.getElementById(id);
return el.innerHTML;
}
// Pure - paas the document as dependancy - easy to mock test.
var getHTML = function(doc, id) {
var el = doc.getElementById(id);
return el.innerHTML;
}
// Unit Testing
var stubDoc = {
getElementById: function(id) {
if (id === 'causewaycom-nav') return { innerHTML: 'Twas brillig…' };
}
};
assert.equal(getHTML(stubDoc, 'causewaycom-nav'), 'Twas brillig…');
//=> test passes
// Dependancy Injection using Pure function from Causway UI styles
(function (window, document, jQuery) {
'use strict';
jQuery('input, textarea').placeholder({classname: 'placeholder-style'});
......
}(window, document, jQuery));
Pure functions are completely self-contained. Everything the function needs is handed to it on a silver platter. Ponder this for a moment... How might this be beneficial? For starters, a function's dependencies are explicit and therefore easier to see and understand - no funny business going on under the hood.
//impure
var signUp = function(attrs) {
var user = saveUser(attrs);
welcomeUser(user);
};
var saveUser = function(attrs) {
var user = Db.save(attrs);
...
};
var welcomeUser = function(user) {
Email(user, ...);
...
};
//pure
var signUp = function(Db, Email, attrs) {
return function() {
var user = saveUser(Db, attrs);
welcomeUser(Email, user);
};
};
var saveUser = function(Db, attrs) {
...
};
var welcomeUser = function(Email, user) {
...
};
The example here demonstrates that the pure function must be honest about its dependencies.
It will take some time to get used to these ideas, but soon you’ll find yourself applying them without even thinking about it. Your fellow developers and your future self will thank you.
This is where the magic happens
// ES5 we had to do these statements to define default parameters:
var link = function (height, color, url) {
var height = height || 50
var color = color || 'red'
var url = url || 'causeway.com'
...
}
/*They were okay until the value was 0 and because 0 is falsy
in JavaScript it would default to the hard-coded value instead
of becoming the value itself.*/
// In ES6, we can put the default values right in the signature of the functions:
var link = function(height = 50, color = 'red', url = 'causeway.com') {
...
}
//String interpolation is a much-needed new feature that is finally available in JS.
let name = 'Harry';
let occupation = 'Wizard';
console.log(`Hi! My name is ${name}. I m a ${occupation}`);
//String Method Old way and New way
//old way
var someText = 'hellokitty';
if (someText.indexOf('kitty') != -1) {
return true;
}
// is now
someText.includes('kitty');
var article = {
title: 'Hello Template Literals',
teaser: 'String interpolation is awesome. Here are some features',
body: 'Lots and lots of sanitized HTML',
tags: ['es6', 'template-literals', 'es6-in-depth']
}
var {title,teaser,body,tags} = article
var html = `
${title}
${teaser}
${body}
`
Hello Template Literals
String interpolation is awesome. Here are some features
Lots and lots of sanitized HTML
// old way
var arr = [12,5,42,55,10];
function doSomething(arr) {
for(let i = 0; i < arr.length; i++) {
if(arr[i] > 32) {
return arr[i];
}
}
}
// new way
arr.find(n => n > 32);
//example2
[ 1, 3, 4, 2 ].find(x => x > 3) // 4
//Array.from
let titleElements = document.querySelectorAll('.article .title');
let titles = Array.from(titleElements).map( t => t.textContent );
console.log(titles);
//ES6 gives us an alternative way to assign variables.
let a = 12, b = 3;
[a, b] = [b, a];
// Swap the values inside a and b, without using extra variables.
var log = req.log, // log has username and password
username = log.username,
password = log.password ;
//In ES6, we can replace the ES5 code above with these statements:
var {username, password} = req.log
It might take some time to get use to the destructuring assignment syntax, but it’s a sweet sugarcoating.
//Quick object initialization of objects from variables.
// Old way ES5
var name = "Johnny", job = "Secret Agent", from = "England";
var person = {
'name': name,
'job': job,
'from': from
};
// New way ES6
let name = "Johnny", job = "Secret Agent", from = "England";
let person = {name, job, from};
// Old way ES5
var arr = [3,5,8];
var plusOne = arr.map(function(n){
return n+1;
});
// New way ES6
let arr = [3,5,8];
let plusOne = arr.map(n => n+1);
function Person() {
// The Person() constructor defines `this` as an instance of itself.
this.age = 0;
setInterval(function growUp() {
// In non-strict mode, the growUp() function defines `this`
// as the global object, which is different from the `this`
// defined by the Person() constructor.
this.age++;
}, 1000);
}
var p = new Person();
function Person() {
var that = this;
that.age = 0;
setInterval(function growUp() {
// The callback refers to the `that` variable of which
// the value is the expected object.
that.age++;
}, 1000);
}
The value of this inside the function is not altered: it is the same as the value of this outside the function. No more var self = this to keep track of the current scope.
function Person(){
this.age = 0;
setInterval(() => {
this.age++; // |this| properly refers to the person object
}, 1000);
}
var p = new Person();
Promises, have been around quite a while and are defined by a spec called Promise/A+. ES6 has adopted this spec for its Promise implementation;
Other Promise libraries: Q, Bluebird, RSVP and others that adhere to this spec.
Promises give us a way to handle asynchronous processing in a more synchronous fashion. They represent a value that we can handle at some point in the future. And, better than callbacks here, Promises give us guarantees about that future value, specifically:
var fetchJSON = function(url) {
return new Promise((resolve, reject) => {
$.getJSON(url)
.done((json) => resolve(json))
.fail((xhr, status, err) => reject(status + err.message));
});
}
var itemUrls = {
'http://www.api.com/items/1234',
'http://www.api.com/items/4567'
},
itemPromises = itemUrls.map(fetchJSON);
Promise.all(itemPromises)
.then(function(results) {
// we only get here if ALL promises fulfill
results.forEach(function(item) {
// process item
});
})
.catch(function(err) {
// Will catch failure of first failed promise
console.log("Failed:", err);
});
// A Promise that times out after ms milliseconds
function delay(ms) {
return new Promise((resolve, reject) => {
setTimeout(resolve, ms);
});
}
// Which ever Promise fulfills first is the result passed to our handler
Promise.race([
fetchJSON('http://www.api.com/profile/currentuser'),
delay(5000).then(() => { user: 'guest' })
])
.then(function(json) {
// this will be 'guest' if fetch takes longer than 5 sec.
console.log("user:", json.user);
})
.catch(function(err) {
console.log("error:", err);
});
Source: Dave A.
function calculateTotalAmount (vip) {
var amount = 0
if (vip) {
var amount = 1
}
{ // more crazy blocks!
var amount = 100
{
var amount = 1000
}
}
return amount
}
console.log(calculateTotalAmount(true))
//output 1000;
function calculateTotalAmount (vip) {
var amount = 0 // probably should also be let, but you can mix var and let
if (vip) {
let amount = 1 // first amount is still 0
}
{ // more crazy blocks!
let amount = 100 // first amount is still 0
{
let amount = 1000 // first amount is still 0
}
}
return amount
}
console.log(calculateTotalAmount(true))
//output 0;
//Const turns variables into constants, and they can’t be changed.
const pi = 3.14;
console.log(pi);
const PI = 3.141593
PI > 3.0
//Old way ES5
// only in ES5 through the help of object properties
// and only in global context and not in a block scope
Object.defineProperty(typeof global === "object" ? global : window, "PI", {
value: 3.141593,
enumerable: true,
writable: false,
configurable: false
})
PI > 3.0;
However, they were implemented via libraries, not built into the language.
//------ lib.js ------
export const sqrt = Math.sqrt;
export function square(x) {
return x * x;
}
export function diag(x, y) {
return sqrt(square(x) + square(y));
}
//------ main.js ------
import { square, diag } from 'lib';
console.log(square(11)); // 121
console.log(diag(4, 3)); // 5
//------ main.js ------ import the complete module:
import * as lib from 'lib';
console.log(lib.square(11)); // 121
console.log(lib.diag(4, 3)); // 5
/------ myFunc.js ------
export default function () { ··· } // no semicolon!
//------ main1.js ------
import myFunc from 'myFunc';
myFunc();
Or a class:
//------ MyClass.js ------
export default class { ··· } // no semicolon!
//------ main2.js ------
import MyClass from 'MyClass';
const inst = new MyClass();


High sound.
Special decoration.
Regional berimbau.
Worth buying.
Medium sound.
Special decoration.
Regional berimbau.
Worth buying.
Low sound.
Special decoration.
Regional berimbau.
Be a mestre!


The DNA API package contains interfaces and contracts for DNA components. The DNA component model aims to simplify creation of high quality, reusable software components.


Name Combinator
This tool searches through the dictionary and tries to combine the given phrase with other words that begin or end with a similar spelling. Note that the search term does not need to be a real or complete word.
Search phrase:
| Starting with phrase | Ending with phrase |
|---|---|


score.js
levels, checkpoints and badges for your score
John Doe
Level: {level}
Status: {status}
'{quote}'
Score: {score}
Level score: {levelscore}/{leveltotal}
Total progress: {totalprogress}%
Read more
·
Download on Github


Why ARC isn't Especially Object-Oriented
There is a kind of mania for object-oriented programming at the moment, but some of the smartest programmers I know are some of the least excited about it.
My own feeling is that object-oriented programming is a useful technique in some cases, but it isn't something that has to pervade every program you write. You should be able to define new types, but you shouldn't have to express every program as the definition of new types.
I think there are five reasons people like object-oriented programming, and three and a half of them are bad:
- 1. Object-oriented programming is exciting if you have a statically-typed language without lexical closures or macros. To some degree, it offers a way around these limitations. (See Greenspun's Tenth Rule.)
- 2. Object-oriented programming is popular in big companies, because it suits the way they write software. At big companies, software tends to be written by large (and frequently changing) teams of mediocre programmers. Object-oriented programming imposes a discipline on these programmers that prevents any one of them from doing too much damage. The price is that the resulting code is bloated with protocols and full of duplication. This is not too high a price for big companies, because their software is probably going to be bloated and full of duplication anyway.
- 3. Object-oriented programming generates a lot of what looks like work. Back in the days of fanfold, there was a type of programmer who would only put five or ten lines of code on a page, preceded by twenty lines of elaborately formatted comments. Object-oriented programming is like crack for these people: it lets you incorporate all this scaffolding right into your source code. Something that a Lisp hacker might handle by pushing a symbol onto a list becomes a whole file of classes and methods. So it is a good tool if you want to convince yourself, or someone else, that you are doing a lot of work.
- 4. If a language is itself an object-oriented program, it can be extended by users. Well, maybe. Or maybe you can do even better by offering the sub-concepts of object-oriented programming a la carte.Overloading, for example, is not intrinsically tied to classes. We'll see.
- 5. Object-oriented abstractions map neatly onto the domains of certain specific kinds of programs, like simulations and CAD systems
I personally have never needed object-oriented abstractions. Common Lisp has an enormously powerful object system and I've never used it once. I've done a lot of things (e.g. making hash tables full of closures) that would have required object-oriented techniques to do in wimpier languages, but I have never had to use CLOS.
 There is a danger in designing a language based on one's own experience of programming. But it seems more dangerous to put stuff in that you've never needed because it's thought to be a good idea.


Welcome to Smartkart Grocery Store
Home
Products
cart
Sign Up
Feedback
Please Send us Your Feedback...
First Name
Last Name
Email Address
Contact Number
Comments
Submit


menu
ParseMapper AngularJS
Parse Mapper
AngularJS
developer_mode
Intro
developer_board
Models
transform
Services
transform
Data Processor


---
layout: splash
permalink: /
title: "Ecohydrology, Conservation and Data Science"
header:
overlay_color: "#5e616c"
overlay_image: /assets/images/headers/header.jpg
cta_label: " Plese contact me to exchange ideas or if you have any questions."
cta_url: "/cv/"
caption: "Photocredit: A. Hurley"
excerpt: '
Find out more about me, my projects and interests.'
intro:
- excerpt: 'Follow me on twitter for latest updates. [ @aglhurley](https://twitter.com/aglhurley){: .btn .btn--twitter}'
feature_row1:
- image_path: /assets/images/intro/AOS.jpg
title: "Ecohydrological functioning of Boreal Plain wetlands."
alt: "Ecohydrological functioning of Boreal Plain wetlands."
excerpt: "Shallow wetlands of the sub-humid Boreal Plain have multiple mechanisms that maintain their ecohydrological functioning through climate cycles. I am researching processes that generate surplus water, which may affect the productivity of 'downstream' and adjacent ecosystems. Research outcomes will inform Oil Sand land reclamation."
url: "/research/"
btn_label: "Read More"
btn_class: "btn--inverse"
---
{% include feature_row id="intro" type="center" %}


2K
Members
Many Places
50+ Destination
100+
Partnership
Best Quality
Service anda Facility
Wisata Populer
dengan pelayanan terbaik
hadirkan pengalaman yang tak terlupakan
Our Networks
Companies trusted us
more than just a trip
They Are Loving Us
Moments were giving them
Best Experience
Dicky Setiawan
"this trip, so addicted me haha,, where's Next?"
Trip to Bromo, Indonesia
Dicky Setiawan
"this trip, so addicted me haha,, where's Next?"
Trip to Bromo, Indonesia
Dicky Setiawan
"this trip, so addicted me haha,, where's Next?"
Trip to Bromo, Indonesia


[1]
looks pretty; freezes consistantly, too secure
[2]
Network Engineer; i used vista nearly one month
[3]
New Operating System; Really Gives you nothing


Reaper's Avatar
Further embody the emblem of death and claim lives with unrivaled efficiency.
+${value}% Movement Speed
7 8 9 10 11 12 13 14 15 16 17 18 19 20
+${value}% Offensive Ability
8 9 11 12 14 15 16 18 19 20 22 23 25 26
+${value}% Pierce Damage
12 15 19 22 26 29 32 36 39 42 46 49 53 56
MaxLevel
10
UltimateLevel
14


This page is targeted as a guideline for users who require the use of custom serialization for their state, covering how to provide a custom state serializer as well as guidelines and best practices for implementing serializers that allow state schema evolution.
If you’re simply using Flink’s own serializers, this page is irrelevant and can be ignored.
When registering a managed operator or keyed state, a StateDescriptor
is required
to specify the state’s name, as well as information about the type of the state. The type information is used by Flink’s
type serialization framework to create appropriate serializers for the state.
It is also possible to completely bypass this and let Flink use your own custom serializer to serialize managed states,
simply by directly instantiating the StateDescriptor
with your own TypeSerializer
implementation:
This section explains the user-facing abstractions related to state serialization and schema evolution, and necessary internal details about how Flink interacts with these abstractions.
When restoring from savepoints, Flink allows changing the serializers used to read and write previously registered state,
so that users are not locked in to any specific serialization schema. When state is restored, a new serializer will be
registered for the state (i.e., the serializer that comes with the StateDescriptor
used to access the state in the
restored job). This new serializer may have a different schema than that of the previous serializer. Therefore, when
implementing state serializers, besides the basic logic of reading / writing data, another important thing to keep in
mind is how the serialization schema can be changed in the future.
When speaking of schema, in this context the term is interchangeable between referring to the data model of a state type and the serialized binary format of a state type. The schema, generally speaking, can change for a few cases:
In order for the new execution to have information about the written schema of state and detect whether or not the
schema has changed, upon taking a savepoint of an operator’s state, a snapshot of the state serializer needs to be
written along with the state bytes. This is abstracted a TypeSerializerSnapshot
, explained in the next subsection.
TypeSerializerSnapshot
abstractionA serializer’s TypeSerializerSnapshot
is a point-in-time information that serves as the single source of truth about
the state serializer’s write schema, as well as any additional information mandatory to restore a serializer that
would be identical to the given point-in-time. The logic about what should be written and read at restore time
as the serializer snapshot is defined in the writeSnapshot
and readSnapshot
methods.
Note that the snapshot’s own write schema may also need to change over time (e.g. when you wish to add more information
about the serializer to the snapshot). To facilitate this, snapshots are versioned, with the current version
number defined in the getCurrentVersion
method. On restore, when the serializer snapshot is read from savepoints,
the version of the schema in which the snapshot was written in will be provided to the readSnapshot
method so that
the read implementation can handle different versions.
At restore time, the logic that detects whether or not the new serializer’s schema has changed should be implemented in
the resolveSchemaCompatibility
method. When previous registered state is registered again with new serializers in the
restored execution of an operator, the new serializer is provided to the previous serializer’s snapshot via this method.
This method returns a TypeSerializerSchemaCompatibility
representing the result of the compatibility resolution,
which can be one of the following:
TypeSerializerSchemaCompatibility.compatibleAsIs()
: this result signals that the new serializer is compatible,
meaning that the new serializer has identical schema with the previous serializer. It is possible that the new
serializer has been reconfigured in the resolveSchemaCompatibility
method so that it is compatible.TypeSerializerSchemaCompatibility.compatibleAfterMigration()
: this result signals that the new serializer has a
different serialization schema, and it is possible to migrate from the old schema by using the previous serializer
(which recognizes the old schema) to read bytes into state objects, and then rewriting the object back to bytes with
the new serializer (which recognizes the new schema).TypeSerializerSchemaCompatibility.incompatible()
: this result signals that the new serializer has a
different serialization schema, but it is not possible to migrate from the old schema.The last bit of detail is how the previous serializer is obtained in the case that migration is required.
Another important role of a serializer’s TypeSerializerSnapshot
is that it serves as a factory to restore
the previous serializer. More specifically, the TypeSerializerSnapshot
should implement the restoreSerializer
method
to instantiate a serializer instance that recognizes the previous serializer’s schema and configuration, and can therefore
safely read data written by the previous serializer.
TypeSerializer
and TypeSerializerSnapshot
abstractionsTo wrap up, this section concludes how Flink, or more specifically the state backends, interact with the abstractions. The interaction is slightly different depending on the state backend, but this is orthogonal to the implementation of state serializers and their serializer snapshots.
RocksDBStateBackend
)TypeSerializer
for the state is used to read / write state on every state access.TypeSerializer#snapshotConfiguration
method.TypeSerializer#resolveSchemaCompatibility
to check for schema compatibility.TypeSerializerSnapshot#restoreSerializer()
, and is used to deserialize state bytes to objects, which in turn
are re-written again with the new serializer, which recognizes schema B to complete the migration. All entries
of the accessed state is migrated all-together before processing continues.MemoryStateBackend
, FsStateBackend
)TypeSerializer
is maintained by the state backend.TypeSerializer#snapshotConfiguration
method.TypeSerializerSnapshot#restoreSerializer()
, and is used to deserialize state bytes to objects.TypeSerializer#resolveSchemaCompatibility
to check for schema compatibility.A serializer’s snapshot, being the single source of truth for how a registered state was serialized, serves as an entry point to reading state in savepoints. In order to be able to restore and access previous state, the previous state serializer’s snapshot must be able to be restored.
Flink restores serializer snapshots by first instantiating the TypeSerializerSnapshot
with its classname (written
along with the snapshot bytes). Therefore, to avoid being subject to unintended classname changes or instantiation
failures, TypeSerializerSnapshot
classes should:
TypeSerializerSnapshot
class across different serializersSince schema compatibility checks goes through the serializer snapshots, having multiple serializers returning
the same TypeSerializerSnapshot
class as their snapshot would complicate the implementation for the
TypeSerializerSnapshot#resolveSchemaCompatibility
and TypeSerializerSnapshot#restoreSerializer()
method.
This would also be a bad separation of concerns; a single serializer’s serialization schema,
configuration, as well as how to restore it, should be consolidated in its own dedicated TypeSerializerSnapshot
class.
CompositeSerializerSnapshot
utility for serializers that contain nested serializersThere may be cases where a TypeSerializer
relies on other nested TypeSerializer
s; take for example Flink’s
TupleSerializer
, where it is configured with nested TypeSerializer
s for the tuple fields. In this case,
the snapshot of the most outer serializer should also contain snapshots of the nested serializers.
The CompositeSerializerSnapshot
can be used specifically for this scenario. It wraps the logic of resolving
the overall schema compatibility check result for the composite serializer.
For an example of how it should be used, one can refer to Flink’s
ListSerializerSnapshot implementation.
This section is a guide for API migration from serializers and serializer snapshots that existed before Flink 1.7.
Before Flink 1.7, serializer snapshots were implemented as a TypeSerializerConfigSnapshot
(which is now deprecated,
and will eventually be removed in the future to be fully replaced by the new TypeSerializerSnapshot
interface).
Moreover, the responsibility of serializer schema compatibility checks lived within the TypeSerializer
,
implemented in the TypeSerializer#ensureCompatibility(TypeSerializerConfigSnapshot)
method.
Another major difference between the new and old abstractions is that the deprecated TypeSerializerConfigSnapshot
did not have the capability of instantiating the previous serializer. Therefore, in the case where your serializer
still returns a subclass of TypeSerializerConfigSnapshot
as its snapshot, the serializer instance itself will always
be written to savepoints using Java serialization so that the previous serializer may be available at restore time.
This is very undesirable, since whether or not restoring the job will be successful is susceptible to availability
of the previous serializer’s class, or in general, whether or not the serializer instance can be read back at restore
time using Java serialization. This means that you be limited to the same serializer for your state,
and could be problematic once you want to upgrade serializer classes or perform schema migration.
To be future-proof and have flexibility to migrate your state serializers and schema, it is highly recommended to migrate from the old abstractions. The steps to do this is as follows:
TypeSerializerSnapshot
. This will be the new snapshot for your serializer.TypeSerializerSnapshot
as the serializer snapshot for your serializer in the
TypeSerializer#snapshotConfiguration()
method.TypeSerializerConfigSnapshot
of the serializer must still exist in the classpath,
and the implementation for the TypeSerializer#ensureCompatibility(TypeSerializerConfigSnapshot)
method must not be
removed. The purpose of this process is to replace the TypeSerializerConfigSnapshot
written in old savepoints
with the newly implemented TypeSerializerSnapshot
for the serializer.TypeSerializerSnapshot
as the
state serializer snapshot, and the serializer instance will no longer be written in the savepoint.
At this point, it is now safe to remove all implementations of the old abstraction (remove the old
TypeSerializerConfigSnapshot
implementation as will as the
TypeSerializer#ensureCompatibility(TypeSerializerConfigSnapshot)
from the serializer).


3 Minutes, Nine Days Divine Mercy Novena
Fifth Day:
Today Bring to Me the Souls of Those Who Have Separated Themselves From My Church
Say one Our Father, One Hail Mary and Glory be to the Father
(Add your personal Intention)
Let's pray
Most Merciful Jesus, Goodness Itself, You do not refuse light to those who seek it of You.
Receive into the abode of Your Most Compassionate Heart the souls of those who have separated themselves from Your Church.
Draw them by Your light into the unity of the Church, and do not let them escape from the abode of Your Most Compassionate Heart;
but bring it about that they, too, come to glorify the generosity of Your mercy.

Do not look upon their errors, but upon the love of Your own Son and upon His bitter Passion,
which He underwent for their sake, since they, too, are enclosed in His Most Compassionate Heart.
Bring it about that they also may glorify Your great mercy for endless ages. Amen.
|


[gecode-users] Recovering gracefully from a failed solution
Adrian Secord
ajsecord at cs.nyu.edu
Wed Feb 24 20:51:01 CET 2010
Hi, all:
My colleagues and I are working on a user interface research project that uses Gecode internally to solve integer set problems. Our experiences with Gecode have been excellent; we are limited mostly by our lack of knowledge in the field of constraint programming.
In our application, the constraints in our problems come from the user via a domain-appropriate user interface and we translate them into Gecode equivalents. The difficulty is that the user might specify constraints that lead to no solutions being found at all. Our users are not experts.
What we'd like to do is give the user feedback about what they can do to best fix the situation, or possibly fix the situation for them. In particular, the constraints that come from the user are not necessarily set in stone -- they are vague and messy, a problem with humans. ;) For our application, it is far better to ignore a constraint and come up with some solution than to not return a solution at all. The user can then adjust and iterate to get to a final solution.
Is there some way to determine what was the "worst" or "tightest" constraint after a solution search failed? I'm looking for some indicator that constraint A was easy to satisfy while constraint B was difficult to satisfy. If we had that then we could suggest that the user drop B, or drop it automatically.
I could probably do this crudely by iteratively dropping each constraint in turn and counting the number of solutions obtained, but this seems unsatisfying in many respects.
Is something like this possible in Gecode? It's similar in some sense to the problem of soft constraints, but we don't need a full general solution.
Any pointers or advice would be appreciated.
Thanks!
Adrian.
More information about the users
mailing list