text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
Find many duplicate rules in memory by using iptables_manager
Bug Description
I installed VPNaas In my devstack. I find many duplicate iptables rules in memory. The rule is ' 2015-04-23 10:55:15.380 ERROR neutron.
You've reported this as a private security vulnerability, which implies that you believe it represents an exploitable condition in the software. Please clarify the way in which you would expect a malicious party to take advantage of this bug.
Please provide a part of iptables output showing duplicate rules
[Expired for neutron because there has been no activity for 60 days.]
2018-08-27 10:07:32.989 3258 INFO neutron.
2018-08-27 10:07:32.990 3258 INFO neutron.
2018-08-27 10:07:32.990 3258 INFO neutron.
2018-08-27 10:07:32.990 3258 INFO neutron.
2018-08-27 10:07:32.990 3258 INFO neutron.
2018-08-27 10:07:32.991 3258 INFO neutron.
def _weed_out_
# remove any rules or chains from the filter that were slated
# for removal
if line.startswith
chain = line[1:]
if chain in table.remove_
return False
else:
if line in table.remove_rules:
# Leave it alone
return True
You can see that when you get the iptables rule name in the code “line[1:]”,
there is a count after the chain name, and the count value changes,
which invalidates the judgment
There is append a IptablesRule instance into"self.rules" when I add a iptables rule into memory in iptables_
manager. py. If memory has already exists this rule? Does the iptables_manager weed out it? The code writes "for rule in rules" in _modify_rules function. Why does check the rules exists in memory first? | https://bugs.launchpad.net/neutron/+bug/1447651 | CC-MAIN-2019-04 | en | refinedweb |
using System; public class Control { } public interface IDragDrop { void Drag(); void Drop(); } public interface ISerializable { void Serialize(); } public interface ICombo : IDragDrop, ISerializable { // This interface doesn't add anything new in // terms of behavior as its only purpose is // to combine the IDragDrop and ISerializable // interfaces into one interface. } public class MyTreeView : Control, ICombo { public void Drag() { Console.WriteLine("MyTreeView.Drag called"); } public void Drop() { Console.WriteLine("MyTreeView.Drop called"); } public void Serialize() { Console.WriteLine("MyTreeView.Serialize called"); } } class CombiningApp { public static void Main() { MyTreeView tree = new MyTreeView(); tree.Drag(); tree.Drop(); tree.Serialize(); }
With the ability to combine interfaces, you can not only simplify the ability to aggregate semantically related interfaces into a single interface, but also add additional methods to the new "composite" interface, if needed.
Summary
Interfaces in C# allow the development of classes that can share features but that are not part of the same class hierarchy. Interfaces play a special role in C# development because C# doesn't support multiple inheritance. To share semantically related methods and properties, classes can implement multiple interfaces. Also, the is and as operators can be used to determine whether a particular interface is implemented by an object, which can help prevent errors associated with using interface members. Finally, explicit member naming and name hiding can be used to control interface implementation and to help prevent errors. | https://www.brainbell.com/tutors/C_Sharp/Combining_Interfaces.htm | CC-MAIN-2019-04 | en | refinedweb |
By Subalaxmi Venkataraman on Dec 10, 2018 6:04:31 AM
Windows Presentation Foundation offers various controls and one of the basic control is the combo box.
The combo box has various events such as DropDownOpened, DropDownClosed, SelectionChanged, GotFocus, etc.,.
In this blog, we will see how to handle the selectionchanged event of combo box which is inside grid using Model–View–Viewmodel (MVVM) pattern.
Create Model (Person):
Define a class Person as show below.
Create View Model:
Create a view model named MainWindowViewModel.cs
Create View:
Create a view named MainWindow.xaml.
In the above code, `Cities' are defined in the view model and are not part of Persons class, the ItemsSource is defined as ItemsSource="{Binding Path=DataContext.Cities,RelativeSource={RelativeSource FindAncestor, AncestorType = UserControl}}" which will take the data from viewmodel Cities property.
We need to import the namespace xmlns:i=".
View Codebehind:
Create view model field and instantiate the view model in the constructor of View Code behind file.
MainWindow.xaml.cs
When we run the application, the grid will bind with the person details and city combo box will be bound with the cities list. Now we can change the city for the respective person and it will be handled by the CityChangeCommand in the view model class.
In this manner we can handle the combo box selection change event using MVVM pattern in WPF. | https://blog.trigent.com/handling-combo-box-selection-change-in-viewmodel-wpf-mvvm-2 | CC-MAIN-2019-04 | en | refinedweb |
The address control in InforCRM 8.2 (and other versions) is implemented as a semi-dynamic Javascript widget. I say semi-dynamic because while the widget is driven by configuration, the configuration is very much hard-coded. In this post I will examine how to do common customizations of this dialog.
A little bit of background
The address control is implemented in 2 parts:
- Sage.SalesLogix.Web.Controls.AddressControl, the C# code which is going to generate the HTML as well as some of the client script (including the field configuration)
- Sage.UI.Controls.Address, the Javascript widget which is going to drive the interaction
This widget uses 2 templates:
- Address.html – the text area shown on the detail page
- AddressEdit.html – the template for the dialog
Bear in mind you cannot modify those templates – they are compiled into the product. If you look at the AddressEdit.html file you will see the form is built dynamically based on the
fields property of the Address control. Therefore our work will consist mainly of manipulating that property.
Obtaining a reference to the dijit
This is always the first step.
Now you have 2 options. One is to make a form-specific customization – e.g. if you just want to change the address widget on the account detail screen, then load your code on that form (using
ScriptManager.RegisterStartupScript) and grab the dijit using its client-side id:
ScriptManager.RegisterStartupScript(this, GetType(), "CustomizeAddress", String.Format(@" dojo.ready(function() {{ setTimeout(function() {{ var control = dijit.byId('{0}'); if(control) {{ // do some stuff with control now }} }}); }}); ", address.ClientID), true);
The 2nd option is more useful, in my opinion – it comes into play if you want to make customizations to all address dialogs shown through the app regardless of the form. To do that we can monkey-patch the Address control prototype so that our code is loaded whenever that control is instantiated.
I am going to put this code in a new file, CustomizeAddressDialog.js, and load that file via a module – CustomizeAddressDialogModule. Check out Including Custom Javascript in Saleslogix if you are not familiar with that technique.
require(['dojo/aspect', 'Sage/UI/Controls/Address'], function (aspect, Address) { aspect.after(Address.prototype, 'postCreate', function() { var control = this; // do some stuff with control now }); });
This is nice because you don’t have to worry about customizing every form… but it will affect every address control in the app (including Lead) so something to keep in mind. If that is a problem you could always register it as a module just on the pages that you want to modify.
Removing fields
Here you just need to remove the field from the
fields array. Here is a common use case, remove the “Address Type” field added in 8.2 (many users feel it is confusing because it makes double usage with the Description field):
for(var i=0; i < control.fields.length; i++) { if(control.fields[i].name == 'addressType') { control.fields.splice(i, 1); break; } }
Modifying fields
Same idea as in the previous code, but we need to change the field object, usually the
xtype property (which determines the type of widget created). Here is another common use case, to change the City dropdown into a text box (this would go in the same loop as the one above):
if(control.fields[i].name == 'city') { control.fields[i].xtype = 'textfield'; }
Adding fields
Adding a field is a lot harder because the C# control would need to have support for it in order for data binding to work, so we quickly get stuck here. Ideally the code-behind control should create additional hidden fields dynamically based on the custom properties registered on the Address entity but until that happens we’ll only be able to come up with hack solutions here.
Putting it together
Module:
using Sage.Platform.Application; using System.Web; using System.Web.UI; namespace Custom.Modules { public class CustomizeAddressDialogModule : IModule { public void Load() { Page page = HttpContext.Current.Handler as Page; if (page == null) return; ScriptManager.RegisterClientScriptInclude(page, page.GetType(), "CustomizeAddressLeads", HttpContext.Current.Request.ApplicationPath + "/Custom/js/Address/CustomizeAddressDialog.js"); } } }
Javascript:
require(['dojo/aspect', 'Sage/UI/Controls/Address'], function (aspect, Address) { aspect.after(Address.prototype, 'postCreate', function () { var control = this; for (var i = 0; i < control.fields.length; i++) { if (control.fields[i].name == 'city' || control.fields[i].name == 'state') { control.fields[i].xtype = 'textfield'; } else if (control.fields[i].name == 'addressType') { control.fields.splice(i, 1); i--; } } }); });
In conclusion
We can see the control is not very difficult to do basic customizations with, though more advanced customizations are not currently possible without a hack.
I hope this is helpful and if you do some cool address customizations or have any trick to add be sure to mention them in the comments. | https://www.xtivia.com/customizing-inforcrm-address-dialog/ | CC-MAIN-2019-04 | en | refinedweb |
There are many reasons to include OneSignal (aka the OneSignalNotificationServiceExtension) in your own app. But there are also good reasons to remove the popular framework from your app. For example, if you don’t need it and want to save app storage space. Or because otherwise, problems with the app submission or other frameworks occur. This guide will help you remove OneSignal from your iOS app built with the WebViewGold app template..
Step 1: Remove the OneSignal Notification Extension
In your Xcode project, navigate to the General tab, choose the
OneSignalNotificationServiceExtension target, and click Edit / Delete.
Afterward, please select the
OneSignalNotificationServiceExtension folder from the left sidebar and choose Edit / Delete, too. When asked if you want to remove the references or the whole files, choose Move To Trash:
Step 2: Remove the OneSignal pod entry
Open your
Podfile (in the root folder of the Xcode project) using TextEdit (or any other code-compatible editor) and remove the reference to the
OneSignal pod:
pod 'OneSignal', '>= 2.6.2', '< 3.0'
Also, remove this chunk and everything inside that chunk:
target 'OneSignalNotificationServiceExtension' do pod 'OneSignal', '>= 2.6.2', '< 3.0' ... ... end
Step 3: Clean your AppDelegate.swift file
Open your AppDelegate.swift file and remove the following chunks:
import OneSignal
and
if Constants.kPushEnabled { let onesignalInitSettings = [kOSSettingsKeyAutoPrompt: true, kOSSettingsKeyInAppLaunchURL: true] OneSignal.initWithLaunchOptions(launchOptions,appId: "xxxxx-xxxxx-xxxxx-xxxxx-xxxxx",handleNotificationAction: {(result) in let payload = result?.notification.payload if let additionalData = payload?.additionalData { let noti_url = additionalData["url"] as! String UserDefaults.standard.set(noti_url, forKey: "Noti_Url") NotificationCenter.default.post(name: NSNotification.Name(rawValue: "OpenWithNotificationURL"), object: nil, userInfo: nil) }},settings: onesignalInitSettings) OneSignal.inFocusDisplayType = OSNotificationDisplayType.inAppAlert; }
Step 4: Click “Build” and fix all dependency errors
Now it is time for Xcode to build the app. To do this, click on the play icon (“Build”). There will be some errors (red icons). Click on each error in turn and fix it by commenting out or deleting the corresponding line (or the complete code block if it’s a function or e.g., an if/else operation).
Enjoy!
Again:.
Get WebViewGold for iOS here | https://www.webapp2app.com/2020/11/09/remove-onesignal-onesignalnotificationserviceextension-from-webviewgold-ios-app-project/ | CC-MAIN-2020-50 | en | refinedweb |
REPL Prompt missing and no response after connection
I am using LoPy4 on a Pysense board and had it all working. I was using Atom successfully and uploading files no problem. I could also telnet to the device.
I'm using MacOS 10.13.3
I should add on first use I updated the Pysense firmware using 'dfu-util -D pysense_0.0.8.dfu' and then updated the LoPy4 firmware - it said it was updating to 1.17.3b1 (I assume this is the latest but can't find a list of release numbers anywhere).
I have been testing LoRa using the example code in the docs to access LoRaWAN (OTAA) (unsuccessfully so far), and tried some web server examples using MicroWebSrv & MicroDNSSrv.
At some stage the REPL console stopped responding. On Atom I could initiate a connection, the Atom connection window would say 'Connected' but in the console window, after 'Connecting on /dev/tty.usbmodemPY... there was no '>>>' prompt.
The same happens with Telnet. I can log in ok, get the 'Help()' message, but no response after that.
I have tried Ctrl-B, & Ctrl-D, etc with no response. I've tried entering a command (blind) but still no response.
I have reloaded the firmware a few times.
I have tried using battery only and connecting via telnet, same result.
The Blue LED heartbeat flashing continues ok all through this.
Any suggestions?
@robert-hh Thanks, that did it!
I had to do the P12 to 3.3V for the 7-9s to load the factory firmware.
I retested a firmware update and it went back to the unresponsive mode. So I then reformatted the /flash area by running:
import os
os.mkfs('/flash')
A firmware update then worked ok.
Thanks again.
@brentoon You could try a safe boot. Connect P12 to 3.3V and push the reset button (next to the RGB LED). Safe boot ignores boot.py and main.py on boot. Similar is trying Ctrl-F in the REPL prompt.
To avoid all other dependencies with Atom and the pymakr plugin, connect via USB using a simple terminal emulator like screen. That should be available on OS X. | https://forum.pycom.io/topic/2948/repl-prompt-missing-and-no-response-after-connection/3 | CC-MAIN-2020-50 | en | refinedweb |
Like ui-router, but without all the Angular. The best way to structure a single-page webapp.
resolve
state.go('logout')or having the user click on a link
<a href="{{ asr.makePath('logout') }}">logout</a>
I posted this in the MobX gitter earlier:
I have a question which may seem sort of stupid.
I am a massive fan of MobX with injected store decorators and observer/observable pattern, it makes sense and deprecates the need the for "state" if you will in components since they're essentially "hot-wired" to the store (global app state).
I've been using state management libraries since Flux was introduced, before Redux ever existed.
I'm curious if there's a way to make an agnostic implementation of MobX that you can configure to work with Vue/React/Angular/Aurelia, etc.
Every time I've used MobX, I've needed (or appeared to need) a "binding" package for that UI framework.
Would it not be possible to write an agnostic implementation that you could pass framework elements or functions into for context?
import createStateRouter from 'abstract-state-router'; import Vue from 'vue'; import App from './App'; const VueInstance = new Vue({ el: '#app', template: '<App/>', components: { App }, data: { someGlobalStorePackageOrObject } }); const stateRouter = createStateRouter(makeRenderer, VueInstance)
import createStateRouter from 'abstract-state-router' import makeVueStateRenderer from 'vue-state-renderer' import hookUpStoreToAllRenderedStates from 'library-that-you-could-make' import reduxOrWhateverAdapter from 'adapter-library-for-library-that-you-could-make' import App from './App' const renderer = hookUpStoreToAllRenderedStates(makeVueStateRenderer(), reduxOrWhateverAdapter()) const stateRouter = createStateRouter(renderer) stateRouter.add({ name: 'app', route: 'app', template: App }) | https://gitter.im/TehShrike/abstract-state-router?at=59ed586e5c40c1ba79d3ab4b | CC-MAIN-2020-50 | en | refinedweb |
Simple Interrupt Problem
I was working on a significantly more complex programs and having some problems that I traced back to the fact that the interrupt wasn't firing.
I've written a new, extremely simple program just to prove to myself that I can make interrupts work, and its not going so well.
it uses the user button on the expansion board to trigger interrupts to increment a counter (or at least that's the idea)
here's the contents of boot.py, there is no main.py:
import micropython from machine import Pin micropython.alloc_emergency_exception_buf(100) int_counter =0 def int_handler(): global int_counter int_counter+=1 button=Pin('GP17', mode=Pin.IN, pull=Pin.PULL_UP) button.irq(trigger=Pin.IRQ_RISING|Pin.IRQ_FALLING, handler=int_handler)
I know the pin setup is working because when I go to the repl and run button() I get a value that toggles as I press and release the button
I know the handler function works because when I manually run int_handler(), int_counter increments.
Further, I suspect the trigger is working because when I press the button for the first time, the heartbeat LED blinks very rapidly for a couple seconds. However it won't do that again unless the button.irq() method is re-called.
However, when I press the button, int_counter does not increment.
Any idea what's going on here? I'm stumped
This works:
import micropython from machine import Pin micropython.alloc_emergency_exception_buf(100) int_counter =0 def int_handler(pin_obj): global int_counter int_counter+=1 button=Pin('GP17', mode=Pin.IN, pull=Pin.PULL_UP) button.irq(trigger=Pin.IRQ_RISING|Pin.IRQ_FALLING, handler=int_handler)
The key is that the "os" passes the pin object to the callback function as an argument. However, if your callback function isnt expecting any arguments, this causes an exception. Since the exception occurs outside of the main program execution its a little confusing to debug.
@KMcLoud or @LoneTech Any chance you could share some working interrupt code? I'm stuck trying to make this work myself... Thanks!
Thank you so much, that fixed it!
I'm hugely supportive of all the awesome work you guys are doing!
Is there any way I can contribute to the docs to make that more clear? because I read them over a couple times never picked that up.
a note on the "make a post" page indicating you need to use ``` instead of the BBcode would be super helpful too, any way I could help with that?
This post is deleted!
This post is deleted!
Use triple backticks
```for code blocks.
Pininterrupt handlers are called with the pin as an argument, so you need to add an argument for
int_handler. | https://forum.pycom.io/topic/148/simple-interrupt-problem/1 | CC-MAIN-2019-09 | en | refinedweb |
AngularJS and RequireJS can live together
Note: I pulled this from an old abandoned site. It will be hopelessly out of date by now
The Players
AngularJS includes a module system to help decouple code, but it stops short of locating the code in files. The modules and the DI help to take a lot of rough edges off day-to-day code, but it can’t get rid of the need to list all your neat little JS files in a big lump at the end of your page.
RequireJS uses the AMD API to find and load dependencies for modules (in this case, modules are 1–1 with files). It does it by surrounding all the code you write in a (sometimes contentious) wrapper to define a factory function. The factories are invoked once all dependencies are resolved.
The Conflict
The two systems can play nice together, despite the clash over the name “module”, but not quite in the default configuration. New AngularJS projects usually bootstrap an “application module” and the internal mechanics of both libraries leads to a situation where RequireJS hasn’t produced the application module in time for AngularJS to bootstrap it.
Simple Resolution
The simplest fix is to manually bootstrap Angular with the application module
once enough of the system has loaded. Using the
ng-app directive causes the
auto-bootstrap to run, so remove it and replace all scripts with the require.js
script pointing at main.js. Now all JS files should contain AMD modules and the
bootstrap code in main.js is what starts the application running:
- Remove the
ng-appdirective and point Require at the main file.
<body> <div ng-view></div> <script data-</script> </body>
- Use a shim to blend Angular into the AMD namespace
require.config({ shim: { angular: { deps: ['jquery'], exports: 'angular' } }});
- Define the Angular application module as an AMD module
define(function(require){ 'use strict'; return require('angular').module('myApp', []) .config(['$routeProvider', function($routeProvider) { $routeProvider.when('/', { templateUrl: 'views/main.html', controller: require('controllers/main') }); }]); });
- Bootstrap the module once loaded.
require( ['angular', 'app'], function(angular, app) { angular.bootstrap(document, [app.name]); });
main.js should just contain this and the RequireJS config.
Note how the controllers can be referenced via
require(). It’s just as easy
to register services and the rest:
mod.controller('LogViewCtrl', require('controllers/logview')); mod.service('BackendService', require('services/backend'));
Lasting Solution
The recipe above solves one problem — referring to files instead of globals — but script loaders can also be used for lazy loading. Any application that uses the router will probably have separate top-level views and could benefit from only loading the code for the current view.
Plenty of
people
have
tackled this
problem.
The solution is usually to delay the completion of routing until the controller
script has loaded. If you follow the links, you’ll see that require isn’t the
only game in town. I’ve heard rumours of integrations with
goog.require().
I had some fun looking for a more complete solution, and by fun I mean rummaging through the guts of the Angular code as well as comparing approaches taken by different people. I tried extending the core providers to resolve AMD module references and a couple of other dead-ends. And then I got tired of chasing the perfect solution: I don’t need lazy loading that badly. But I am fond of a bit of module structure. | https://stackfull.github.io/blog/2012/12/30/angularjs_and_requirej.html | CC-MAIN-2019-09 | en | refinedweb |
Simple Homework!
Bütçe $30-100 USD
Deadline is 6 Hours! I can pay 10 usd coz its a simple 1/2 hour work i think so
Hi, can you help me with this homework? Please let me know the cost and how fast can you finish it. Thanks.
Questions on Marshalling.
Base on the following java code, let say you’re required to send the object instance stored in DevilBlack to another system (given that the main method has been done).
You have two options: If you prefer Java-like object serialization then draw a diagram. Otherwise write an XML document in SOAP environment, (definitions of data types is not required) that illustrates how DevilBlack can be represented as a sequence of bytes (marshaled). You are not able to send the DevilBlack object instance on its own. Besides, you have to send other object instances if they can be accessed from DevilBlack. Keep in mind AngelBlue is a rival of DevilBlack.
public class AngelBlue
{
public static void main ()
{
Person DevilBlack = new Person ();
Person AngelBlue = new Person ();
Person cupids[] = new Person[7];
[url removed, login to view] = "Devil Black";
[url removed, login to view] = 65;
[url removed, login to view] = null;
[url removed, login to view] = new Person[] { AngelBlue };
[url removed, login to view] = "Angel Blue";
[url removed, login to view] = 18;
[url removed, login to view] = cupids;;
[url removed, login to view] = null;
for (int i=0; i < 7; i++)
{
cupids[i] = new Person ();
cupids[i].name = "Cupid" + [url removed, login to view](i);
cupids[i].age = 101;
cupids[i].friends = null;
cupids[i].rivals = null;
}
/* We have a “send operation” to send the object instance that
* stored in DevilBlack to another system.
*/
}
}
public class Person
{
public string name; // Name of the person
public int age; // Age of the person
public Person friends[]; // People who are friends of this person
public Person rivals[]; // People who are rivals of this person
}
Bu iş için 4 freelancer ortalamada $43 teklif veriyor
Hello,Please refer your PMB.Thankyou.
I have done with assignment
please check pm | https://www.tr.freelancer.com/projects/java/simple-homework/ | CC-MAIN-2019-09 | en | refinedweb |
Realm Tutorial: Getting Started
Learn how to use Realm, a popular cross-platform mobile database that is an alternative to Core Data.
Version
- Other, Other, Other
Update note: This tutorial was updated for iOS 9 and Swift 2.2 by Bradley Johnson. Original tutorial was by team member Bill Kastanakis.
Realm is a cross-platform mobile database solution designed specifically for mobile applications.
It’s fast, lightweight, and extremely simple to integrate in your project.:
let fetchRequest = NSFetchRequest(entityName: "Specimen") let predicate = NSPredicate(format: "name BEGINSWITH [c]%@", searchString) fetchRequest.predicate = predicate let sortDescriptor = NSSortDescriptor(key: "name", ascending: true) fetchRequest.sortDescriptors = [sortDescriptor] do { let results = try managedObjectContext?.executeFetchRequest(fetchRequest) } catch { ... }
What takes quite a few lines with Core Data can be achieved with far fewer lines in Realm:
let predicate = NSPredicate(format: "name BEGINSWITH [c]%@", searchString); do { let specimens = try Realm().objects(Specimen).filter(predicate).sorted("name", ascending: true) } catch { ... }
Working with Realm results in more concise code — which makes it easier to write and read your code.
This Realm tutorial will introduce you to the basic features of Realm on iOS. You’ll learn how to link in the Realm framework, create models, perform queries, and update records.
Getting Started
Here’s the scenario: you’ve accepted a position as an intern in the National Park Service and your job is to document the species found in the biggest national parks in the United States. You need an assistant to keep notes and document your findings, but the agency doesn’t have an assistant to spare, nor the budget to hire a new one. Instead, you’ll create a virtual assistant for yourself — an app named “Agents Partner”.
Download the starter project for this tutorial here: AgentsPartner_Starter
Open the starter project in Xcode. MapKit is already set up in your project. Right now your app only contains instances of
UITableView and
MKMapView to provide the map functionality.
The starter project is missing Realm, so it’s time to add it.
One great way to install Realm is with CocoaPods. CocoaPods is a dependency manager for Swift and Objective-C Cocoa projects, and it has thousands of libraries you can download and use in your own projects.
Create a file called ‘Podfile’ in the root directory of the starter project (To do this in command line simply use the command
touch Podfile). Copy the following chunk of text and paste it into your Podfile:
platform :ios, ‘9.0’ use_frameworks! target ‘Agents Partner’ do pod 'RealmSwift', '~> 0.98' end
Save and close your Podfile. Back in the command line, in the root directory of your project (the same location your Podfile is in), run the command
pod install. This tells CocoaPods to scan through your Podfile and install any pods you have listed in your Podfile. Pretty neat! It may take several minutes for Realm to install, keep an eye on your terminal and once it’s complete you will see a line near the bottom that begins with
Pod installation complete!.
Open the root directory of the starter project in finder, and you will now see some folders that CocoaPods placed there, in addition to Agents Partner.xcworkspace. If you currently have your Agents Partner starter project open in Xcode, close it now, and then double click to open the .xcworkspace file. This is now the file you will open when you want to work on this project. If you open the regular project file by mistake, Xcode won’t properly be able to find any of the dependencies you installed with CocoaPods, so you must use the .xcworkspace file instead. Expand the Agents Partner project in the Project navigator, and then the group/folder also named Agents Partner to reveal the files you will be working with.
Thats it! Build and run the project to ensure everything compiles. If not, re-check the steps above carefully. You should see a basic screen like so:
Introducing Realm Browser
Realm also provides a nice utility that you’ll want to install from the App Store to make your life a little easier.
The Realm Browser lets you read and edit Realm databases. It’s really useful while developing as the Realm database format is proprietary and not easily human-readable. Download it here.
Concepts and Major Classes
In order to better understand what Realm does, here’s an overview of the Realm classes and concepts you’ll use in this tutorial:
Realm: Realm instances are the heart of the framework; it’s your access point to the underlying database, similar to a Core Data managed object context. You will create instances using the
Realm() initializer.
Object: This is your Realm model. The act of creating a model defines the schema of the database; to create a model you simply subclass
Object and define the fields you want to persist as properties.
Relationships: You create one-to-many relationships between objects by simply declaring a property of the type of the
Object you want to refer to. You can create many-to-one and many-to-many relationships via a property of type
List, which leads you to…
Write Transactions: Any operations in the database such as creating, editing, or deleting objects must be performed within writes which are done by calling
write(_:) on
Realm instances.
Queries: To retrieve objects from the database you’ll need to use queries. The simplest form of a query is calling
objects() on a
Realm instance, passing in the class of the
Object you are looking for. If your data retrieval needs are more complex you can make use of predicates, chain your queries, and order your results as well.
Results: Results is an auto updating container type that you get back from object queries. They have a lot of similarities with regular
Arrays, including the subscript syntax for grabbing an item at an index.
Now that you’ve had an introduction to Realm, it’s time to get your feet wet and build the rest of the project for this tutorial.
Creating Your First Model
Open Specimen.swift from the Models group and add the following implementation:
import Foundation import RealmSwift class Specimen: Object { dynamic var name = "" dynamic var specimenDescription = "" dynamic var latitude = 0.0 dynamic var longitude = 0.0 dynamic var created = NSDate() }
The code above adds a few properties:
name and
specimenDescription store the specimen’s name and:
[spoiler title=”Category object”]
Once you’ve created a new Swift file Category.swift, its contents should look like this:
import Foundation import RealmSwift class Category : Object { dynamic var name = "" }
[/spoiler] other properties:
dynamic var category: Category!
This sets up a one-to-many relationship between
Specimen and
Category..
Before you start writing code to integrate Realm into this view controller, you must first import the RealmSwift framework in this source file. Add the following line to the top of the file, just below
import UIKit:
import RealmSwift
You’ll need to populate this table view with some default categories. You can store these
Category instances in an instance of
Results.
CategoriesTableViewController has a
categories array as a placeholder for now. Find the following code at the top of the class definition:
var categories = []
and replace it with the following lines:
let realm = try! Realm() lazy var categories: Results<Category> = { self.realm.objects(Category) }()
When you you need to fetch objects, you always need to define which models you want. In the code above you first create a
Realm instance, and then populate
categories by calling
objects(_:) on it, passing in the class name of the model type you want.
try!when calling Realm methods that throw an error. In your own code, you should really be using
tryand
do/
catchto catch errors and handle them appropriately.
You’ll want to give your user some default categories to choose from the first time the app runs.
Add the following helper method to the class definition, below
preferredStatusBarStyle:
func populateDefaultCategories() { if categories.count == 0 { // 1 try! realm.write() { // 2 let defaultCategories = ["Birds", "Mammals", "Flora", "Reptiles", "Arachnids" ] // 3 for category in defaultCategories { // 4 let newCategory = Category() newCategory.name = category self.realm.add(newCategory) } } categories = realm.objects(Category) // 5 } }
Taking each numbered line in turn:
- If
counthere is equal to 0 this means the database has no
Categoryrecords, which is the case the first time you run the app.
- This starts a transaction on
realm— you’re now ready to add some records to the database.
- Here you create the list of default category names and then iterate through them.
- For each category name, you create a new instance of
Category, populate
nameand add the object to the realm.
- Finally, you fetch all of the categories you just created and store them in
categories.
Add the following line to the end of
viewDidLoad():
populateDefaultCategories():
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCellWithIdentifier("CategoryCell", forIndexPath: indexPath) let category = categories[indexPath.row] cell.textLabel?.text = category.name return cell }
This implementation retrieves a category from
categories based on the index path and then sets the cell’s text label to show the category’s
name.
Next, add this property below the other properties you just added to
CategoriesTableViewController:
var selectedCategory: Category!
You’ll use this property to store the currently selected
Category.
Find
tableView(_:willSelectRowAtIndexPath:) and replace the entire method with the following:
override func tableView(tableView: UITableView, willSelectRowAtIndexPath indexPath: NSIndexPath) -> NSIndexPath { selectedCategory = categories[indexPath.row] return indexPath }
This will now store the user’s selection import the RealmSwift framework. Add the following line to the top of the file, just below the existing
import statements at the top of the file:
import RealmSwift
Now add the following line to
viewDidLoad() just after the call to
super.viewDidLoad():
print(Realm.Configuration.defaultConfiguration.path!)
This line simply prints the database location to the debug console. It’s a short step to then browse the database using the Realm Browser.
Build and run your app; you’ll see that it reports the location of the database in the Xcode console.
The easiest way to go to the database location is to open Finder, press Cmd-Shift-G and paste in the path your app reported..
If you haven’t yet downloaded Realm Browser, download it now from the Mac App Store. Double-click default.realm to open it with Realm Browser:
Once the database is open in Realm Browser, you’ll see Category with a 5 next to it. This means that this class contains five records. Click a class to inspect the individual fields contained within.
Adding Categories
Now you can implement the logic to set the
category of a
Specimen.
Open AddNewEntryController.swift and import the RealmSwift framework. Once again, import Realm at the top of the file, just below the existing import statements:
import RealmSwift
Now add the following property to the class:
var selectedCategory: Category!
You’ll use this to store the selected
Category.
Next, find
unwindFromCategories() and add the following implementation:
if segue.identifier == "CategorySelectedSegue" { let categoriesController = segue.sourceViewController as! CategoriesTableViewController selectedCategory = categoriesController.selectedCategory categoryTextField.text = selectedCategory.name }
unwindFromCategories() is called when the user selects a category from
CategoriesTableViewController, which you set up in the previous step. Here, you retrieve the selected category, store it locally in
selectedCategory, and then fill in the text field with the category’s name.
Now that you have your categories taken care of, you can create your first
Specimen!
Still in AddNewEntryController.swift, add one more property to the class:
var specimen: Specimen!
This property will store the new specimen object.
Next, add the helper method below to the class:
func addNewSpecimen() { let realm = try! Realm() // 1 try! realm.write { // 2 let newSpecimen = Specimen() // 3 newSpecimen.name = self.nameTextField.text! // 4 newSpecimen.category = self.selectedCategory newSpecimen.specimenDescription = self.descriptionTextField.text newSpecimen.latitude = self.selectedAnnotation.coordinate.latitude newSpecimen.longitude = self.selectedAnnotation.coordinate.longitude realm.add(newSpecimen) // 5 self.specimen = newSpecimen // 6 } }
Here’s what the code above does:
- You first get a
Realminstance, as before.
- Here you start the write transaction to add your new
Specimen.
- Next, you create a new
Specimeninstance.
- Then you assign the
Specimenvalues. The values come from the text input fields in the user interface, the selected categories, and the coordinates from the map annotation.
- Then you add the new
Specimento the realm.
- Finally, you assign the new
Specimento your
specimenproperty.
You’ll need some sort of validator to make sure all the fields are populated correctly in your
Specimen.
validateFields() in
AddNewEntryController exists to do just this: check for a specimen name and description. Since you’ve just added the ability to assign a category to a specimen, you’ll need to check for that field too.
Still in AddNewEntryController.swift, find the line in
validateFields() that looks like this:
if nameTextField.text!.isEmpty || descriptionTextField.text!.isEmpty {
Change that line to this:
if nameTextField.text!.isEmpty || descriptionTextField.text!.isEmpty || selectedCategory == nil {
This verifies that all fields have been filled in and that you’ve selected a category as well.
Next, add the following method to the class:
override func shouldPerformSegueWithIdentifier(identifier: String?, sender: AnyObject?) -> Bool { if validateFields() { addNewSpecimen() return true } else { return false } }
In the above code you call the method to validate the fields; only if everything is filled in do you.
First, take another look at the updated database in the Realm Browser:
You’ll see your one lonely specimen, with all fields filled along with the latitude and longitude from the
MKAnnotation. You’ll also see the link to your specimen’s category — that means your one-to-many
Category relationship is working as expected. Click the
Category in your
Specimen record to view the
Category record itself.
Now you need to populate the map in the app.
Open SpecimenAnnotation.swift and add a property to the class:
var specimen: Specimen?
This will hold the
Specimen for the annotation.
Next, replace the initializer with the following:
init(coordinate: CLLocationCoordinate2D, title: String, subtitle: String, specimen: Specimen? = nil) { self.coordinate = coordinate self.title = title self.subtitle = subtitle self.specimen = specimen }
The change here is to add an option to pass in a
Specimen.:
var specimens = try! Realm().objects(Specimen)
Since you want to store a collection of specimens in this property, you simply ask a
Realm instance for all objects of type
Specimen.
Now you’ll need some sort of mechanism to populate the map. Still in MapViewController.swift, add the following method to the class:
func populateMap() { mapView.removeAnnotations(mapView.annotations) // 1 specimens = try! Realm().objects(Specimen) // 2 // Create annotations for each one for specimen in specimens { // 3 let coord = CLLocationCoordinate2D(latitude: specimen.latitude, longitude: specimen.longitude); let specimenAnnotation = SpecimenAnnotation(coordinate: coord, title: specimen.name, subtitle: specimen.category.name, specimen: specimen) mapView.addAnnotation(specimenAnnotation) // 4 } }
Taking each numbered comment in turn:
- First, you clear out all the existing annotations on the map to start fresh.
- Next, you refresh your
specimensproperty.
- You then loop through
specimensand create a
SpecimenAnnotationwith the coordinates of the specimen, as well as its
nameand
category.
- Finally, you add each
specimenAnnotationto the
MKMapView.
Now you need to call this method from somewhere. Find
viewDidLoad() and add this line to the end of its implementation:
populateMap()
That will ensure the map will be populated with the specimens whenever the map view controller loads.
Finally you just need to modify your annotation to include the specimen name and category. Find
unwindFromAddNewEntry(_:) and replace the method with the following implementation:
@IBAction func unwindFromAddNewEntry(segue: UIStoryboardSegue) { let addNewEntryController = segue.sourceViewController as! AddNewEntryController let addedSpecimen = addNewEntryController.specimen let addedSpecimenCoordinate = CLLocationCoordinate2D(latitude: addedSpecimen.latitude, longitude: addedSpecimen.longitude) if let lastAnnotation = lastAnnotation { mapView.removeAnnotation(lastAnnotation) } else { for annotation in mapView.annotations { if let currentAnnotation = annotation as? SpecimenAnnotation { if currentAnnotation.coordinate.latitude == addedSpecimenCoordinate.latitude && currentAnnotation.coordinate.longitude == addedSpecimenCoordinate.longitude { mapView.removeAnnotation(currentAnnotation) break } } } } let annotation = SpecimenAnnotation(coordinate: addedSpecimenCoordinate, title: addedSpecimen.name, subtitle: addedSpecimen.category.name, specimen: addedSpecimen) mapView.addAnnotation(annotation) lastAnnotation = nil; } icon to the category-specific icon. Here you simply remove the last annotation added to the map (the generic-looking one) and replace it with an annotation that shows the name and category of the specimen.. You will now populate this table view with some data.
Open LogViewController.swift and import
RealmSwift again below the other
import statements:
import RealmSwift
Then replace the
specimens property with the following:
var specimens = try! Realm().objects(Specimen).sorted("name", ascending: true)
In the code above, you replace the placeholder array with a
Results which will hold
Specimens just as you did in
MapViewController. They will be sorted by
name.
Next, replace
tableView(_:cellForRowAtIndexPath:) with the following implementation:
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell { let cell = self.tableView.dequeueReusableCellWithIdentifier("LogCell") as! LogCell let specimen = specimens[indexPath.row] cell.titleLabel.text = specimen.name cell.subtitleLabel.text = specimen.category.name switch specimen.category.name { case "Uncategorized": cell.iconImageView.image = UIImage(named: "IconUncategorized") case "Reptiles": cell.iconImageView.image = UIImage(named: "IconReptile") case "Flora": cell.iconImageView.image = UIImage(named: "IconFlora") case "Birds": cell.iconImageView.image = UIImage(named: "IconBird") case "Arachnid": cell.iconImageView.image = UIImage(named: "IconArachnid") case "Mammals": cell.iconImageView.image = UIImage(named: "IconMammal") default: cell.iconImageView.image = UIImage(named: "IconUncategorized") } return cell }
This method will now populate the cell with the specimen’s name and category..
Build and run your app. Tap Log and you’ll see all of your entered specimens in the table view like so:.
In LogViewController.swift, replace the
searchResults property with the following:
var searchResults = try! Realm().objects(Specimen)
Now add the method below to the class:
func filterResultsWithSearchString(searchString: String) { let predicate = NSPredicate(format: "name BEGINSWITH [c]%@", searchString) // 1 let scopeIndex = searchController.searchBar.selectedScopeButtonIndex // 2 let realm = try! Realm() switch scopeIndex { case 0: searchResults = realm.objects(Specimen).filter(predicate).sorted("name", ascending: true) // 3 case 1: searchResults = realm.objects(Specimen).filter(predicate).sorted("created", ascending: true) // 4 default: searchResults = realm.objects(Specimen).filter(predicate) // 5 } }
Here’s what the above function does:
- First you create a predicate which searches for
names that start with
searchString. The
[c]that follows
BEGINSWITHindicates a case insensitive search.
- You then grab a reference to the currently selected scope index from the search bar
- If the first segmented button is selected, sort the results by name ascending.
- If the second button is selected, sort the results by created date ascending.
- If none of the buttons are selected, don’t sort the results — just take them in the order they’re returned from the database.
Now you need to actually perform the filtering when the user interacts with the search field. In
updateSearchResultsForSearchController(_:) add the following two lines at the beginning of the method:
let searchString = searchController.searchBar.text! filterResultsWithSearchString(searchString)
Since the search results table view calls the same data source methods, you’ll need a small change to
tableView(_:cellForRowAtIndexPath:) to handle both the main log table view and the search results. In that method, find the line that assigns to
specimen:
let specimen = specimens[indexPath.row]
Delete that one line and replace it with the following:
let specimen = searchController.active ? searchResults[indexPath.row] : specimens[indexPath.row]
The above code checks whether the
searchController is active; if so, it retrieves the specimen from
searchResults; if not, then it retrieves the specimen from
specimens instead.
Finally you’ll need to add a function to sort the returned results when the user taps a button in the scope bar.
Replace the empty
scopeChanged(_:) with the code below:
@IBAction func scopeChanged(sender: AnyObject) { let scopeBar = sender as! UISegmentedControl let realm = try! Realm() switch scopeBar.selectedSegmentIndex { case 0: specimens = realm.objects(Specimen).sorted("name", ascending: true) case 1: specimens = realm.objects(Specimen).sorted("created", ascending: true) default: specimens = realm.objects(Specimen).sorted("name", ascending: true) } tableView.reloadData() }
In the code above you check which scope button is pressed — A-Z, or Date Added — and call
arraySortedByProperty(_:ascending:) accordingly. By default, the list will sort by
name.
Build and run your app; try a few different searches and see what you get for results!
Updating Records
You’ve covered the addition of records, but what about when you want to update them?:
func fillTextFields() { nameTextField.text = specimen.name categoryTextField.text = specimen.category.name descriptionTextField.text = specimen.specimenDescription selectedCategory = specimen.category }
This method will fill in the user interface with the specimen data. Remember,
AddNewEntryViewController has up to this point only been used for new specimens, so those fields have always started out empty.
Next, add the following lines to the end of
viewDidLoad():
if let specimen = specimen { title = "Edit \(specimen.name)" fillTextFields() } else { title = "Add New Specimen" }:
func updateSpecimen() { let realm = try! Realm() try! realm.write { self.specimen.name = self.nameTextField.text! self.specimen.category = self.selectedCategory self.specimen.specimenDescription = self.descriptionTextField.text } }
As usual, the method begins with getting a
Realm instance and then the rest is wrapped inside a
write() transaction. Inside the transaction, you simply update the three data fields.
Six lines of code to update the
Specimen record is all it takes! :]
Now you need to call the above method when the user taps Confirm. Find
shouldPerformSegueWithIdentifier(_:sender:) and replace it with the following:
override func shouldPerformSegueWithIdentifier(identifier: String?, sender: AnyObject?) -> Bool { if validateFields() { if specimen != nil { updateSpecimen() } else { addNewSpecimen() } return true } else { return false } }
This will call your helper method to update the data when appropriate.
Now open LogViewController.swift and add the following implementation for
prepareForSegue(_:sender:):
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject!) { if (segue.identifier == "Edit") { let controller = segue.destinationViewController as! AddNewEntryController var selectedSpecimen: Specimen! let indexPath = tableView.indexPathForSelectedRow if searchController.active { let searchResultsController = searchController.searchResultsController as! UITableViewController let indexPathSearch = searchResultsController.tableView.indexPathForSelectedRow selectedSpecimen = searchResults[indexPathSearch!.row] } else { selectedSpecimen = specimens[indexPath!.row] } controller.specimen = selectedSpecimen } }.
Where to Go From Here?
You can download the finished project here.
In this Realm tutorial you’ve learned how to create, update, delete and fetch records from a Realm database, how to use predicates, and sort the results by their properties.
There are many other features of Realm that weren’t touched on in this tutorial, like migrations and concurrency. You can learn about those topics and much more in the official documentation, which are very good.
If you have any comments or questions on this tutorial or Realm in general, please join the discussion below! | https://www.raywenderlich.com/1464-realm-tutorial-getting-started | CC-MAIN-2019-09 | en | refinedweb |
View Complete Post
Downloaded the latest Ribbon Control Library from microsoft.
Created a new WPF Ribbon Application, and create a few simple buttons and tabs.
Problem: When I navigate away from my Ribbon Window to another app (ie browser), when I come back the the Ribbon Application the Ribbon will sometimes be frozen. I cannot click any buttons or switch tabs, only the application menu is still active.
I can fix it my maximizing the window oddly. Is this a know problem? How do I fix it? I can provide a small sample app if needed.
Please check into this Microsoft :).
Thanks,
Kevin
<ribbon:RibbonWindow x:Class="Main"
xmlns=""
xmlns:x=""
xmlns:ribbon="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary"
Title="Main"
x:
<Grid x:
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefini
I've done a fair amount of looking, but I have not found what I am looking for.
I would like a ribbon control that I drag from the ribbon to a canvas below. In addition, I would like a combobox resting just below the control that allows me to change the content available for drag.
Is there a control out there that does this or should I build my own? If I build my own, how should i go about doing this??
When I use the SPCalendarView control in a custom visual webpart, the navigation for expand all, collapse all, Day, Week, and Month, all show up in the calendar control itself, like SP2007 without the ribbon. Is there a way to change this behavior
to make it assume these will be in the ribbon and not show up in the control.
Right now I am just hiding them via css.
When you look at the OOTB calendar view used in a library, it puts this stuff in the ribbon in SP2010.
Here is data binding expression (dropdown list is nested in gridview)
<asp:DropDownList
Code Behind has function which looks like
public int GetSelectedIndex(DropDownList ddl)
{
//loop through the item in the dropdownlist
//return index based on xyz checks
}
The whole reason for passing the reference is to save round trip to database and not to use SESSION
i am in stress how to start this what should be the first step
i want to create custom application
page with a ribbon and some user
control web part to show document item properties.
Please help me regarding this
thanks in advance
Regards
WasiKhan
Fritz Onion demonstrates how the ListView control in ASP.NET 3.5 makes data-binding tasks easier with support for styling with CSS, flexible pagination, and a full complement of sorting, inserting, deleting, and updating features.
Fritz Onion
MSDN Magazine March 2008
If you want to create your own professional looking tabs and controls in Office, check out the RibbonX API of the 2007 Microsoft Office system.
Eric Faller
Dino Esposito
MSDN Magazine April 2001 | http://www.dotnetspark.com/links/14221-wpf-ribbon-control-binding-to-vm-ribbon.aspx | CC-MAIN-2017-13 | en | refinedweb |
dart-spell
A simple spell checker implementation in Dart. For now it only finds the single words from a given dictionary. Algorithm is different than Peter Norvig's implementation (). This implementation is more complicated but probably much faster (finds several thousands matches in a second). It uses dynamic decoding over a simple trie generated from the dictionary. System finds words with a distance to the input. Deletions, insertions, substitutions and transpositions are supported.
import 'package:dart_spell/dart_spell.dart'; ... // optional distance parameter. Default is 1.0 var checker = new SingleWordSpellChecker(distance:1.0); var dictionary = ["apple", "apples", "pear", "ear"]; checker.addWords(dictionary); List<Result> matches = checker.find("apple"); print(matches); Output: [apple:0.0, apples:1.0]
##TODO Add less substitution penalty for near keys in keyboard layout. Add language model support so that it gives more logical suggestions. * Add multi word spell suggestion with space and out of vocabulary word handling. | https://www.dartdocs.org/documentation/dart_spell/0.1.0/index.html | CC-MAIN-2017-13 | en | refinedweb |
.
The dot (or period),
. is probably the most used,
and certainly the most well-known character class.
By default,
a dot matches any character,
except for the newline... Experimental. \pP, \p{Prop} Match a character that has the given Unicode property. \PP, \P{Prop} Match a character that doesn't have the Unicode property
\d matches a single character that is there is a locale in effect, it will match whatever characters the locale considers decimal digits. Without a locale,
\d matches just the digits '0' to '9'.
Unicode digits may cause some confusion, and some security issues. In UTF-8 strings,
\d matches the same characters matched subscripts.
The design intent is for
\d to match all the digits (and no other characters) that can be used with "normal" big-endian positional decimal syntax, whereby a sequence of such digits {N0, N1, N2, ...Nn} has the numeric value (...(N0 * 10 + N1) * 10 + N2) * 10 ... + Nn). In Unicode 5.2, the Tamil digits (U+0BE6 - U+0BEF) can also legally be used in old-style Tamil numbers in which they would appear no more than one in a row, separated by characters that mean "times 10", "times 100", etc. (See.)
Some of the that isn't matched by
\d will be matched by
\D.
A
\w matches a single alphanumeric character (an alphabetic character, or a decimal digit) or an underscore (
_), not a whole word. To match a whole word, use
\w+. This isn't the same thing as matching an English word, but is the same as a string of Perl-identifier characters. What is considered a word character depends on several factors, detailed below in "Locale, EBCDIC, Unicode and UTF-8". If those factors indicate a Unicode interpretation,
\w matches the characters that are considered word characters in the Unicode database. That is, it not only matches ASCII letters, but also Thai letters, Greek letters, etc. If a Unicode interpretation is not indicated,
\w matches those characters that are considered word characters by the current locale or EBCDIC code page. Without a locale or EBCDIC code page,
\w matches the ASCII letters, digits and the underscore., "ID_Start", ID_Continue", "XID_Start", and "XID_Continue". See.
Any character that isn't matched by
\w will be matched by
\W.
\s matches any single character that is horizontal tab (
\t), the newline (
\n), the form feed (
\f), the carriage return (
\r), and the space. (Note that it doesn't match the vertical tab,
\cK.) Perhaps the most notable possible surprise is that
\s matches a non-breaking space only if a Unicode interpretation is indicated, or the locale or EBCDIC code page that is in effect has that character.
Any character that isn't matched by
\s will be matched by
\S.
\h will match any character that is considered horizontal whitespace; this includes the space and the tab characters and a number other characters, all of which are listed in the table below.
\H will match any character that is not considered horizontal whitespace.
\v will match any character that is considered vertical whitespace; this includes the carriage return and line feed characters (newline) plus several other characters, all, without regard to other factors, such as if the source string is in UTF-8 format or not. (ASCII-platform
"\x85") and the no-break space (ASCII-platform
"
NEXT LINE and NO-BREAK SPACE only match
\s if+.
\N is new in 5.12, and is experimental. It, like the dot, will match class, follow the character class with a quantifier. For instance,
[aeiou]+ matches a string of one or more lowercase English+wide.) will be considered a character that is to be matched literally. You have to escape the hyphen with a backslash if you want to have a hyphen in your set of characters to be matched, and its position in the class is such that it could any backslash sequence character class (with the exception of
\N) inside a bracketed character class, and it will act just as if you put all the characters matched by the backslash sequence inside the character class. For instance,
[a-f\d] will match any decimal digit, or any of the lowercase letters between 'a' and 'f' inclusive.
\N within a bracketed character class must be of the forms
\N{name} or
\N{U+wide hex char}, and NOT be the form that matches non-newlines, for the same reason that a dot
. inside a bracketed character class loses its special meaning: it matches nearly anything, which generally isn't what you want to happen.").umerical" plus the vertical tab ("\cK"). upper Any uppercase character ("[A-Z]"). word A Perl extension ("[A-Za-z0-9_]"), equivalent to "\w". xdigit Any hexadecimal digit ("[0-9a-fA-F]")., will only match characters in the ASCII character set.] below)}
\p{Blank} and
\p{HorizSpace} are synonyms. 159.
Any character that is graphical, that is, visible. This class consists of all the alphanumerical characters and all punctuation characters.
All printable characters, which is the set of all the graphical characters plus whitespace characters that are not also controls.
\p{PosixPunct} and
[[:punct:]] in the ASCII range match all the non-controls, non-alphanumeric, non-space characters:
[-!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~] (although if a locale is in effect, it could alter the behavior of
[[:punct:]]).
\p{Punct} matches a somewhat different set in the ASCII range, namely
[-!"#%&'()*,./:;?@[\\\]_{}]. That is, it is missing
[$+<=>^`|~]. This is because Unicode splits what POSIX considers to be punctuation into two categories, Punctuation and Symbols.
When the matching string is in UTF-8 format,
[[:punct:]] matches what it matches in the ASCII range, plus what
\p{Punct} matches. This is different than strictly matching according to
\p{Punct}. Another way to say it is that for a UTF-8 string,
[[:punct:]] matches all the characters that Unicode considers to be punctuation, plus all the ASCII-range characters that Unicode considers to be symbols.
\p{SpacePerl} and
\p{Space} differ only in that
\p{Space} additionally matches the vertical tab,
\cK. Same for the two ASCII-only range forms.{Digit} \D [[:^space:]] \P{PosixSpace} \P{Space} \P{PerlSpace} \P{SpacePerl} \S [[:^word:]] \P{PerlWord} \P{Word} \W
Perl will recognize the POSIX character classes
[=class=], and
[.class.], but does not (yet?) support them. Use of such a construct will lead to an error.
/[['.
Some of the character classes have a somewhat different behaviour depending on the internal encoding of the source string, if the regular expression is marked as having Unicode semantics, the locale that is in effect, and if.)
The rule is that if the source string is in UTF-8 format or the regular expression is marked as indicating Unicode semantics (see the next paragraph), the character classes match according to the Unicode properties. Otherwise, the character classes match according to whatever locale or EBCDIC code page is in effect. If there is no locale nor EBCDIC, they match the ASCII defaults (0 to 9 for
\d; 52 letters, 10 digits and underscore for
\w; etc.)., it may be better to not use
\w,
\d,
\s or the POSIX character classes, and use the Unicode properties instead. That way you can control whether you want matching of just characters in the ASCII character set, or any Unicode characters.
use feature "unicode_strings" will allow seamless Unicode behavior no matter what the internal encodings are, but won't allow restricting to just the ASCII characters.
. | http://search.cpan.org/~miyagawa/perl-5.13.6/pod/perlrecharclass.pod | CC-MAIN-2017-13 | en | refinedweb |
User Tag List
Results 1 to 1 of 1
Thread: Error loading Page
- Join Date
- Jan 2006
- 10
- Mentioned
- 0 Post(s)
- Tagged
- 0 Thread(s)
Error loading Page
Hope anyone can be of help to me.
I'm working on this small application and I'm experiencing this message coming up when I test the page. In IE, I get this message below but Its too vauge I can't seem to trace the problem eventhough the page displays but with error.
Line: 63
Char: 16
Error: Exptected '/'
Code: 0.
URL:
Firstly, the Default.aspx has got a line 63. I disabled the javascript files attached but the same message keeps coming up so I figure its not the javascript file
In Firefox, the page doesn't display at all but the following message is displayed:
XML Parsing Error: no element found
Location:
Line Number 1, Column 1:
The Default.aspx file is using a master file so i figured the XML namespace might just be the problem but the declaration is fine. Not sure what it means by no element found. I have double checked the syntax in both the aspx files and the master pages put can't seem to find the problem. I figured intellisense would have highlighted that for me in anycase.
Has anyone encountered a similar thing before? Any clues or leads? Its really frustrating and been at it a few days now.
Thanks in advance
Bookmarks | http://www.sitepoint.com/forums/showthread.php?504634-Error-loading-Page&p=3554210 | CC-MAIN-2017-13 | en | refinedweb |
What is it good for?
The project delivers configurable board support code for selected targets, and docs. Besides its modest size, the TG9541/STM8EF code has a long feature list. Using the code for embedded control applications is subject to new projects.
The code on GitHub can be used in many ways:
- for writing alternative firmware Chinese commodity boards (e.g. thermostats, DCDC converters, or relay boards)
- for embedded systems with an interactive shell (scriptable and extensible)
- for creating smart SPI, I2C, or RS232 smart sensors :-)
Right now, the W1209 is my favorite for communicating, or for sensing. What if you need sensing and communication at the same time? Maybe the "update connector" can be used as a home brew field bus interface? A lot is possible with the right idea, and the right software!
Which target boards are supported?
Besides generic CORE target for STM8S003F3P6, there is currently support for the following boards:
- MINDEV STM8S103F3P6 Breakout Board or similar
- W1209 Thermostat Board (3 7S-LED, 3 keys, relay)
- W1401 Thermostat Board (3x2 7S-LED, 4 keys, relay, buzzer)
- C0135 Relay Board-4 (4 inputs, 1 key, 1 LED, 4 relays)
@Elliot Williams worked on using the ESP-14 as an IoT deviced (the ESP-14 is an ESP8266 with an STM8S003F3P6 in a ESP-12 package).
Programmable power supplies based on the XH-M188, and a cheap DC/DC converter are work in progress. There are also several types of STM8S003F3 based voltmeters that can be supported.
Read more about likely future targets below.
Why Forth?
Again, because it's fun!
Consider this:
- compared to other programming environments the core of Forth is easy to fully understand
- like Lisp, Forth has a REPL (Read-Evaluate-Print-Loop) which enables software testing in a way impossible with "Edit-Compile-Run-Debug" (e.g. Arduino)
- it's easy to build Domain Specific Languages (you can literally program the compiler!)
- the stack-centered "factoring" approach provides implicit data flow which leads to maintainable code
- Interpreter-compiler, basic OS functions fit in just 4K code :-).
A Forth programmer is in control of all levels of problem
abstraction, a unique advantage in a world where layer on layer of 2nd
hand solutions leads to ever growing complexity (compilers, libraries, operating systems,
drivers,frameworks, IDEs... ). I'm convinced that "Thinking Forth" will make anybody a better programmer, not just in the
domain of embedded control!
Why STM8S003F3 or STM8S103F3?
Low-end...Read more »
Thomas mentioned that a better file loader would be nice. Here is my attempt. Simple to start with, but obviously capable of being expanded with features later. It is in Python2 and runs from the command line of the host machine (mine is LinuxMint).
<code>
#!/usr/bin/env python2
import serial
import sys
import time
port = serial.Serial(
port='/dev/ttyACM0',
baudrate=9600,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=5)
if len(sys.argv) < 2:
print('Usage %s ... [fileN]' % (sys.argv[0]))
sys.exit()
def upload(path):
with open(path) as source:
for line in source.readlines():
time.sleep(0.2)
line = line.strip()
if not line: continue
if len(line) > 64:
raise 'Line is too long: %s' % (line)
print('\n\rsending: ' + line)
port.write(line)
port.write('\n\r')
chin = ''
response_buffer = []
while chin <> '\v':
response_buffer.append(chin)
while port.inWaiting() > 0:
chin = port.read(1)
response = ''.join(response_buffer)
sys.stdout.write(response)
for path in sys.argv[1:]:
print('Uploading %s' % path)
upload(path)
</code>
Usage: Save this code as a file (say named loadserial.py) and change its permissions to be executable (just the lines in between the code tags). I put loadserial.py in my local /bin folder. Edit loadserial.py so the port matches what you use when using a terminal console to connect to STM8 machine.
WARNING: I've just noticed that the indentation was inconsistently displayed, and python is indentation sensitive. So be very careful with just copy-and-paste. I'll put a copy of it up on RigTig's Big 3d Printer project here on hackaday.io.
Either put FILE on first line of the file to be sent, or type it into a terminal console and close it, then use a local command line interface thus: <code> filename file2send </code>. Enjoy! | https://hackaday.io/project/16097-eforth-for-cheap-stm8s-value-line-gadgets | CC-MAIN-2017-13 | en | refinedweb |
.
Now all you have to do, is somewhere in the code that creates (or has access to) "progressBar", you can make that class implement "Notifier.NotificationListNow all you have to do, is somewhere in the code that creates (or has access to) "progressBar", you can make that class implement "Notifier.NotificationList
public class ODSLoader implements Notifier { private List<Notifier.NotificationListener> listeners = new ArrayList<Notifier.NotificationListener>(); public void addListener(Notifier.NotificationListener listener) { listeners.add(listener); } public void removeListener(Notifier.NotificationListener listener) { listeners.remove(listener); } private void notifyListeners() { for (Notifier.NotificationListener listener : listeners) { listener.onNotificationPosted(); } } // All the normal ODSLoader code follows... // But where something interesting happens in the ODSLoader code, you insert a... notifyListeners(); // call that calls the above method to send the notifications to all listeners }
I suppose you have 5 big parts that ODSLoader has to perform.I suppose you have 5 big parts that ODSLoader has to perform.
progressBar = new JProgressBar(0,5);
at the end of each of those parts.at the end of each of those parts.
notifyListeners();
byby
// public static void progress() { // progressBar.setValue(progressBar.getValue() + 1); // }
public void onNotificationPosted() { progressBar.setValue(progressBar.getValue() + 1); }
myODSLoaderInstance.addListener(this);
If you are experiencing a similar issue, please ask a related question
Join the community of 500,000 technology professionals and ask your questions. | https://www.experts-exchange.com/questions/28350231/notificationlistener.html | CC-MAIN-2017-13 | en | refinedweb |
Odoo Help
Odoo is the world's easiest all-in-one management software. It includes hundreds of business apps:
CRM | e-Commerce | Accounting | Inventory | PoS | Project management | MRP | etc.
create timer (count down/ count up) on form view
I want to create timer in odoo view which support run/pause (using button ) something like Soccer match time , min:sec format
I tried below code but it generated an error
api.one
def timer_th(self):
timer_thread = Thread(target=self.timer) timer_thread.start()
def timer(self):
while self.current_time <= self.duration:
time.sleep(1) self.current_time += 1
it gave me AttributeError: environments error
but when I used the code without thread it works but gui wasn't responsive
About This Community
Odoo Training Center
Access to our E-learning platform and experience all Odoo Apps through learning videos, exercises and Quizz.Test it now | https://www.odoo.com/forum/help-1/question/create-timer-count-down-count-up-on-form-view-111077 | CC-MAIN-2017-13 | en | refinedweb |
(For more resources related to this topic, see here.)
In this article, we will implement the Batch and Service layers to complete the architecture.
There are some key concepts underlying this big data architecture:
Immutable state
Abstraction and composition
Constrain complexity
Immutable state is the key, in that it provides true fault-tolerance for the architecture. If a failure is experienced at any level, we can always rebuild the data from the original immutable data. This is in contrast to many existing data systems, where the paradigm is to act on mutable data. This approach may seem simple and logical; however, it exposes the system to a particular kind of risk in which the state is lost or corrupted. It also constrains the system, in that you can only work with the current view of the data; it isn't possible to derive new views of the data. When the architecture is based on a fundamentally immutable state, it becomes both flexible and fault-tolerant.
Abstractions allow us to remove complexity in some cases, and in others they can introduce complexity. It is important to achieve an appropriate set of abstractions that increase our productivity and remove complexity, but at an appropriate cost. It must be noted that all abstractions leak, meaning that when failures occur at a lower abstraction, they will affect the higher-level abstractions. It is therefore often important to be able to make changes within the various layers and understand more than one layer of abstraction. The designs we choose to implement our abstractions must therefore not prevent us from reasoning about or working at the lower levels of abstraction when required. Open source projects are often good at this, because of the obvious access to the code of the lower level abstractions, but even with source code available, it is easy to convolute the abstraction to the extent that it becomes a risk. In a big data solution, we have to work at higher levels of abstraction in order to be productive and deal with the massive complexity, so we need to choose our abstractions carefully. In the case of Storm, Trident represents an appropriate abstraction for dealing with the data-processing complexity, but the lower level Storm API on which Trident is based isn't hidden from us. We are therefore able to easily reason about Trident based on an understanding of lower-level abstractions within Storm.
Another key issue to consider when dealing with complexity and productivity is composition. Composition within a given layer of abstraction allows us to quickly build out a solution that is well tested and easy to reason about. Composition is fundamentally decoupled, while abstraction contains some inherent coupling to the lower-level abstractions—something that we need to be aware of.
Finally, a big data solution needs to constrain complexity. Complexity always equates to risk and cost in the long run, both from a development perspective and from an operational perspective. Real-time solutions will always be more complex than batch-based systems; they also lack some of the qualities we require in terms of performance. Nathan Marz's Lambda architecture attempts to address this by combining the qualities of each type of system to constrain complexity and deliver a truly fault-tolerant architecture.
We divided this flow into preprocessing and "at time" phases, using streams and DRPC streams respectively. We also introduced time windows that allowed us to segment the preprocessed data. In this article, we complete the entire architecture by implementing the Batch and Service layers.
The Service layer is simply a store of a view of the data. In this case, we will store this view in Cassandra, as it is a convenient place to access the state alongside Trident's state. The preprocessed view is identical to the preprocessed view created by Trident, counted elements of the TF-IDF formula (D, DF, and TF), but in the batch case, the dataset is much larger, as it includes the entire history.
The Batch layer is implemented in Hadoop using MapReduce to calculate the preprocessed view of the data. MapReduce is extremely powerful, but like the lower-level Storm API, is potentially too low-level for the problem at hand for the following reasons:
We need to describe the problem as a data pipeline; MapReduce isn't congruent with such a way of thinking
Productivity
We would like to think of a data pipeline in terms of streams of data, tuples within the stream and predicates acting on those tuples. This allows us to easily describe a solution to a data processing problem, but it also promotes composability, in that predicates are fundamentally composable, but pipelines themselves can also be composed to form larger, more complex pipelines. Cascading provides such an abstraction for MapReduce in the same way as Trident does for Storm.
With these tools, approaches, and considerations in place, we can now complete our real-time big data architecture. There are a number of elements, that we will update, and a number of elements that we will add. The following figure illustrates the final architecture, where the elements in light grey will be updated from the existing recipe, and the elements in dark grey will be added in this article:
Implementing TF-IDF in Hadoop
TF-IDF is a well-known problem in the MapReduce communities; it is well-documented and implemented, and it is interesting in that it is sufficiently complex to be useful and instructive at the same time. Cascading has a series of tutorials on TF-IDF at, which documents this implementation well. For this recipe, we shall use a Clojure Domain Specific Language (DSL) called Cascalog that is implemented on top of Cascading. Cascalog has been chosen because it provides a set of abstractions that are very semantically similar to the Trident API and are very terse while still remaining very readable and easy to understand.
Getting ready
Before you begin, please ensure that you have installed Hadoop by following the instructions at.
How to do it…
Start by creating the project using the lein command:
lein new tfidf-cascalog
Next, you need to edit the project.clj file to include the dependencies:
(defproject tfidf-cascalog "0.1.0-SNAPSHOT" :dependencies [[org.clojure/clojure "1.4.0"] [cascalog "1.10.1"] [org.apache.cassandra/cassandra-all "1.1.5"] [clojurewerkz/cassaforte "1.0.0-beta11-SNAPSHOT"] [quintona/cascading-cassandra "0.0.7-SNAPSHOT"] [clj-time "0.5.0"] [cascading.avro/avro-scheme "2.2-SNAPSHOT"] [cascalog-more-taps "0.3.0"] [org.apache.httpcomponents/httpclient "4.2.3"]] :profiles{:dev{:dependencies[[org.apache.hadoop/hadoop-core "0.20.2-dev"] [lein-midje "3.0.1"] [cascalog/midje-cascalog "1.10.1"]]}})
It is always a good idea to validate your dependencies; to do this, execute lein deps and review any errors. In this particular case, cascading-cassandra has not been deployed to clojars, and so you will receive an error message. Simply download the source from and install it into your local repository using Maven.
It is also good practice to understand your dependency tree. This is important to not only prevent duplicate classpath issues, but also to understand what licenses you are subject to. To do this, simply run lein pom, followed by mvn dependency:tree. You can then review the tree for conflicts. In this particular case, you will notice that there are two conflicting versions of Avro. You can fix this by adding the appropriate exclusions:
[org.apache.cassandra/cassandra-all "1.1.5" :exclusions [org.apache.cassandra.deps/avro]]
We then need to create the Clojure-based Cascade queries that will process the document data. We first need to create the query that will create the "D" view of the data; that is, the D portion of the TF-IDF function. This is achieved by defining a Cascalog function that will output a key and a value, which is composed of a set of predicates:
(defn D [src] (let [src (select-fields src ["?doc-id"])] (<- [?key ?d-str] (src ?doc-id) (c/distinct-count ?doc-id :> ?n-docs) (str "twitter" :> ?key) (str ?n-docs :> ?d-str))))
You can define this and any of the following functions in the REPL, or add them to core.clj in your project. If you want to use the REPL, simply use lein repl from within the project folder. The required namespace (the use statement), require, and import definitions can be found in the source code bundle.
We then need to add similar functions to calculate the TF and DF values:
(defn DF [src] (<- [?key ?df-count-str] (src ?doc-id ?time ?df-word) (c/distinct-count ?doc-id ?df-word :> ?df-count) (str ?df-word :> ?key) (str ?df-count :> ?df-count-str))) (defn TF [src] (<- [?key ?tf-count-str] (src ?doc-id ?time ?tf-word) (c/count ?tf-count) (str ?doc-id ?tf-word :> ?key) (str ?tf-count :> ?tf-count-str)))
This Batch layer is only interested in calculating views for all the data leading up to, but not including, the current hour. This is because the data for the current hour will be provided by Trident when it merges this batch view with the view it has calculated. In order to achieve this, we need to filter out all the records that are within the current hour. The following function makes that possible:
(deffilterop timing-correct? [doc-time] (let [now (local-now) interval (in-minutes (interval (from-long doc-time) now))] (if (< interval 60) false true))
Each of the preceding query definitions require a clean stream of words. The text contained in the source documents isn't clean. It still contains stop words. In order to filter these and emit a clean set of words for these queries, we can compose a function that splits the text into words and filters them based on a list of stop words and the time function defined previously:
(defn etl-docs-gen [rain stop] (<- [?doc-id ?time ?word] (rain ?doc-id ?time ?line) (split ?line :> ?word-dirty) ((c/comp s/trim s/lower-case) ?word-dirty :> ?word) (stop ?word :> false) (timing-correct? ?time)))
We will be storing the outputs from our queries to Cassandra, which requires us to define a set of taps for these views:
(defn create-tap [rowkey cassandra-ip] (let [keyspace storm_keyspace column-family "tfidfbatch" scheme (CassandraScheme. cassandra-ip "9160" keyspace column-family rowkey {"cassandra.inputPartitioner"
"org.apache.cassandra.dht.RandomPartitioner" "cassandra.outputPartitioner"
"org.apache.cassandra.dht.RandomPartitioner"}) tap (CassandraTap. scheme)] tap)) (defn create-d-tap [cassandra-ip] (create-tap "d"cassandra-ip)) (defn create-df-tap [cassandra-ip] (create-tap "df" cassandra-ip)) (defn create-tf-tap [cassandra-ip] (create-tap "tf" cassandra-ip))
The way this schema is created means that it will use a static row key and persist name-value pairs from the tuples as column:value within that row. This is congruent with the approach used by the Trident Cassandra adaptor. This is a convenient approach, as it will make our lives easier later.
We can complete the implementation by a providing a function that ties everything together and executes the queries:
(defn execute [in stop cassandra-ip] (cc/connect! cassandra-ip) (sch/set-keyspace storm_keyspace) (let [input (tap/hfs-tap (AvroScheme. (load-schema)) in) stop (hfs-delimited stop :skip-header? true) src (etl-docs-gen input stop)] (?- (create-d-tap cassandra-ip) (D src)) (?- (create-df-tap cassandra-ip) (DF src)) (?- (create-tf-tap cassandra-ip) (TF src))))
Next, we need to get some data to test with. I have created some test data, which is available at. Simply download the project and copy the contents of src/data to the data folder in your project structure.
We can now test this entire implementation. To do this, we need to insert the data into Hadoop:
hadoop fs -copyFromLocal ./data/document.avro data/document.avro hadoop fs -copyFromLocal ./data/en.stop data/en.stop
Then launch the execution from the REPL:
=> (execute "data/document" "data/en.stop" "127.0.0.1")
How it works…
There are many excellent guides on the Cascalog wiki (), but for completeness's sake, the nature of a Cascalog query will be explained here. Before that, however, a revision of Cascading pipelines is required.
The following is quoted from the Cascading documentation ():
Pipe assemblies define what work should be done against tuple streams, which are read from tap sources and written to tap sinks. The work performed on the data stream may include actions such as filtering, transforming, organizing, and calculating. Pipe assemblies may use multiple sources and multiple sinks, and may define splits, merges, and joins to manipulate the tuple streams.
This concept is embodied in Cascalog through the definition of queries. A query takes a set of inputs and applies a list of predicates across the fields in each tuple of the input stream. Queries are composed through the application of many predicates. Queries can also be composed to form larger, more complex queries. In either event, these queries are reduced down into a Cascading pipeline. Cascalog therefore provides an extremely terse and powerful abstraction on top of Cascading; moreover, it enables an excellent development workflow through the REPL. Queries can be easily composed and executed against smaller representative datasets within the REPL, providing the idiomatic API and development workflow that makes Clojure beautiful.
If we unpack the query we defined for TF, we will find the following code:
(defn DF [src] (<- [?key ?df-count-str] (src ?doc-id ?time ?df-word) (c/distinct-count ?doc-id ?df-word :> ?df-count) (str ?df-word :> ?key) (str ?df-count :> ?df-count-str)))
The <- macro defines a query, but does not execute it. The initial vector, [?key ?df-count-str], defines the output fields, which is followed by a list of predicate functions. Each predicate can be one of the following three types:
Generators: A source of data where the underlying source is either a tap or another query.
Operations: Implicit relations that take in input variables defined elsewhere and either act as a function that binds new variables or a filter. Operations typically act within the scope of a single tuple.
Aggregators: Functions that act across tuples to create aggregate representations of data. For example, count and sum.
The :> keyword is used to separate input variables from output variables. If no :> keyword is specified, the variables are considered as input variables for operations and output variables for generators and aggregators.
The (src ?doc-id ?time ?df-word) predicate function names the first three values within the input tuple, whose names are applicable within the query scope. Therefore, if the tuple ("doc1" 123324 "This") arrives in this query, the variables would effectively bind as follows:
?doc-id: "doc1"
?time: 123324
?df-word: "This"
Each predicate within the scope of the query can use any bound value or add new bound variables to the scope of the query. The final set of bound values that are emitted is defined by the output vector.
We defined three queries, each calculating a portion of the value required for the TF-IDF algorithm. These are fed from two single taps, which are files stored in the Hadoop filesystem. The document file is stored using Apache Avro, which provides a high-performance and dynamic serialization layer. Avro takes a record definition and enables serialization/deserialization based on it. The record structure, in this case, is for a document and is defined as follows:
{"namespace": "storm.cookbook", "type": "record", "name": "Document", "fields": [ {"name": "docid", "type": "string"}, {"name": "time", "type": "long"}, {"name": "line", "type": "string"} ] }
Both the stop words and documents are fed through an ETL function that emits a clean set of words that have been filtered. The words are derived by splitting the line field using a regular expression:
(defmapcatop split [line] (s/split line #"[\[\]\\\(\),.)\s]+"))
The ETL function is also a query, which serves as a source for our downstream queries, and defines the [?doc-id ?time ?word] output fields.
The output tap, or sink, is based on the Cassandra scheme. A query defines predicate logic, not the source and destination of data. The sink ensures that the outputs of our queries are sent to Cassandra. The ?- macro executes a query, and it is only at execution time that a query is bound to its source and destination, again allowing for extreme levels of composition. The following, therefore, executes the TF query and outputs to Cassandra:
(?- (create-tf-tap cassandra-ip) (TF src))
There's more…
The Avro test data was created using the test data from the Cascading tutorial at. Within this tutorial is the rain.txt tab-separated data file. A new column was created called time that holds the Unix epoc time in milliseconds. The updated text file was then processed using some basic Java code that leverages Avro:
Schema schema = Schema.parse(SandboxMain.class.getResourceAsStream
("/document.avsc")); File file = new File("document.avro"); DatumWriter<GenericRecord> datumWriter = new GenericDatumWriter<
GenericRecord>(schema); DataFileWriter<GenericRecord> dataFileWriter = new DataFileWriter<
GenericRecord>(datumWriter); dataFileWriter.create(schema, file); BufferedReader reader = new BufferedReader(new InputStreamReader
(SandboxMain.class.getResourceAsStream("/rain.txt"))); String line = null; try { while ((line = reader.readLine()) != null) { String[] tokens = line.split("\t"); GenericRecord docEntry = new GenericData.Record(schema); docEntry.put("docid", tokens[0]); docEntry.put("time", Long.parseLong(tokens[1])); docEntry.put("line", tokens[2]); dataFileWriter.append(docEntry); } } catch (IOException e) { e.printStackTrace(); } dataFileWriter.close();
Persisting documents from Storm
In the previous recipe, we looked at deriving precomputed views of our data taking some immutable data as the source. In that recipe, we used statically created data. In an operational system, we need Storm to store the immutable data into Hadoop so that it can be used in any preprocessing that is required.
How to do it…
As each tuple is processed in Storm, we must generate an Avro record based on the document record definition and append it to the data file within the Hadoop filesystem.
We must create a Trident function that takes each document tuple and stores the associated Avro record.
Within the tfidf-topology project created in, inside the storm.cookbook.tfidf.function package, create a new class named PersistDocumentFunction that extends BaseFunction. Within the prepare function, initialize the Avro schema and document writer:
public void prepare(Map conf, TridentOperationContext context) { try { String path = (String) conf.get("DOCUMENT_PATH"); schema = Schema.parse(PersistDocumentFunction.class .getResourceAsStream("/document.avsc")); File file = new File(path); DatumWriter<GenericRecord> datumWriter = new GenericDatumWriter
<GenericRecord>(schema); dataFileWriter = new DataFileWriter<GenericRecord>(datumWriter); if(file.exists()) dataFileWriter.appendTo(file); else dataFileWriter.create(schema, file); } catch (IOException e) { throw new RuntimeException(e); } }
As each tuple is received, coerce it into an Avro record and add it to the file:
public void execute(TridentTuple tuple, TridentCollector collector) { GenericRecord docEntry = new GenericData.Record(schema); docEntry.put("docid", tuple.getStringByField("documentId")); docEntry.put("time", Time.currentTimeMillis()); docEntry.put("line", tuple.getStringByField("document")); try { dataFileWriter.append(docEntry); dataFileWriter.flush(); } catch (IOException e) { LOG.error("Error writing to document record: " + e); throw new RuntimeException(e); } }
Next, edit the TermTopology.build topology and add the function to the document stream:
documentStream.each(new Fields("documentId","document"), new PersistDocumentFunction(), new Fields());
Finally, include the document path into the topology configuration:
conf.put("DOCUMENT_PATH", "document.avro");
How it works…
There are various logical streams within the topology, and certainly the input for the topology is not in the appropriate state for the recipes in this article containing only URLs. We therefore need to select the correct stream from which to consume tuples, coerce these into Avro records, and serialize them into a file.
The previous recipe will then periodically consume this file. Within the context of the topology definition, include the following code:
Stream documentStream = getUrlStream(topology, spout) .each(new Fields("url"), new DocumentFetchFunction(mimeTypes), new Fields("document", "documentId", "source")); documentStream.each(new Fields("documentId","document"), new PersistDocumentFunction(), new Fields());
The function should consume tuples from the document stream whose tuples are populated with already fetched documents.
Integrating the batch and real-time views
The final step to complete the big data architecture is largely complete already and is surprisingly simple, as is the case with all good functional style designs.
How to do it…
We need three new state sources that represents the D, DF, and TF values computed in the Batch layer. We will combine the values from these states with the existing state before performing the final TF-IDF calculation.
Start from the inside out by creating the combination function called BatchCombiner within the storm.cookbook.tfidf.function package and implement the logic to combine two versions of the same state. One version should be from the current hour, and the other from all the data prior to the current hour:
public void execute(TridentTuple tuple, TridentCollector collector) { try { double d_rt = (double) tuple.getLongByField("d_rt"); double df_rt = (double) tuple.getLongByField("df_rt"); double tf_rt = (double) tuple.getLongByField("tf_rt"); double d_batch = (double) tuple.getLongByField("d_batch"); double df_batch = (double) tuple.getLongByField("df_batch"); double tf_batch = (double) tuple.getLongByField("tf_batch"); collector.emit(new Values(tf_rt + tf_batch,
d_rt + d_batch, df_rt + df_batch)); } catch (Exception e) { } }
Add the state to the topology by adding these calls to the addTFIDFQueryStream function:
TridentState batchDfState = topology.newStaticState
(getBatchStateFactory("df")); TridentState batchDState = topology.newStaticState
(getBatchStateFactory("d")); TridentState batchTfState = topology.newStaticState
(getBatchStateFactory("tf"));
This is supported by the static utility function:
private static StateFactory getBatchStateFactory(String rowKey) { CassandraState.Options options = new CassandraState.Options(); options.keyspace = "storm"; options.columnFamily = "tfidfbatch"; options.rowKey = rowKey; return CassandraState.nonTransactional("localhost", options); }
Within a cluster deployment of Cassandra, simply replace the word localhost with a list of seed node IP addresses. Seed nodes are simply Cassandra nodes, which, when appropriately configured, will know about their peers in the cluster. For more information on Cassandra, please see the online documentation at.
Finally, edit the existing DRPC query to reflect the added state and combiner function:
topology.newDRPCStream("tfidfQuery",drpc) .each(new Fields("args"), new SplitAndProjectToFields(), new Fields("documentId", "term")) .each(new Fields(), new StaticSourceFunction("twitter"), new Fields("source")).stateQuery(tfState, new Fields("documentId", "term"), new MapGet(), new Fields("tf_rt")) .stateQuery(dfState,new Fields("term"), new MapGet(), new Fields("df_rt")) .stateQuery(dState,new Fields("source"), new MapGet(), new Fields("d_rt")) .stateQuery(batchTfState, new Fields("documentId", "term"), new MapGet(), new Fields("tf_batch")) .stateQuery(batchDfState,new Fields("term"), new MapGet(), new Fields("df_batch")) .stateQuery(batchDState,new Fields("source"), new MapGet(), new Fields("d_batch")) .each(new Fields("tf_rt","df_rt", "d_rt","tf_batch","df_batch","d_batch"), new BatchCombiner(),
new Fields("tf","d","df")) .each(new Fields("term","documentId","tf","d", "df"), new TfidfExpression(), new Fields("tfidf")) .each(new Fields("tfidf"), new FilterNull()) .project(new Fields("documentId", "term","tfidf"));
How it works…
We have covered a huge amount of ground to get to this point. We have implemented an entire real-time, big data architecture that is fault-tolerant, scalable, and reliable using purely open source technologies. It is therefore useful at this point to recap the journey we have taken to the point, ending back where we are now:
We learned how to implement a Trident topology and define a stream data pipeline. This data pipeline defines predicates that not only act on tuples but also on persistent, mutable states.
Using this pipeline, we implemented the TF-IDF algorithm.
We separated out the preprocessing stage of the data pipeline from the "at time" stage of the pipeline. We achieved this by implementing a portion of the pipeline in a DRPC stream that is only invoked at "at time".
We then added the concept of time windows to the topology. This allowed us to segment the state into time-window buckets. We chose hours as a convenient segmentation.
We learned how to test a time-dependent topology using the Clojure testing API.
Then, in this article, we implemented the immutable state and the batch computation.
Finally, we combined the batch-computed view with the mutable state to provide a complete solution.
The following flow diagram illustrates the entire process:
With the high-level picture in place, the final DRPC query stream becomes easier to understand. The stream effectively implements the following steps:
.each(SplitAndProjectToFields): This splits the input arguments from the query and projects them out into separate fields in the tuple
.each(StaticSourceFunction): This adds a static value to the stream, which will be required later
.stateQuery(tfState): This queries the state of the tf value for the current hour based on the document ID and term and outputs tf_rt
.stateQuery(dState): This queries the state of the d value for the current hour based on the static source value and outputs d_rt
.stateQuery(dfState): This queries the state of the df value for the current hour based on the term and outputs df_rt
.stateQuery(tfBatchState): This queries the state of the tf value for all previous hours based on the document ID and term and outputs tf_batch
.stateQuery(dBatchState): This queries the state of the d value for all previous hours based on the static source value and outputs d_batch
.stateQuery(dfBatchState): This queries the state of the df value for all previous hours based on the term and outputs df_batch
.each(BatchCombiner): This combines the separate _rt and _batch fields into a single set of values
.each(TfidfExpression): This calculates the TF-IDF final value
.project: This projects just the fields we require in the output
A key to understanding this is that in each stage in this process, the tuple is simply receiving new values and each function is simply adding new named values to the tuple. The state queries are doing the same based on existing fields within the tuple. Finally, we end up with a very "wide" tuple that we trim down before returning the final result.
Summary
In this article, helps in guiding the user through the process of integrating Storm with Hadoop, thus creating a complete Lambda architecture.
Resources for Article :
Further resources on this subject:
- A look into the high-level programming operations for the PHP language [Article]
- Learn how to write faster, lighter, better PHP applications with AJAX [Article]
- Getting started with Leaflet [Article] | https://www.packtpub.com/books/content/integrating-storm-and-hadoop | CC-MAIN-2017-13 | en | refinedweb |
PCAP_CREATE(3PCAP) PCAP_CREATE(3PCAP)
pcap_create - create a live capture handle
#include <pcap/pcap.h> char errbuf[PCAP_ERRBUF_SIZE]; pcap_t *pcap_create(const char *source, char *errbuf); packets can be captured with it; options for the capture, such as promiscuous mode, can be set on the handle before activating it.
pcap_create() returns a pcap_t * on success and NULL on failure. If NULL is returned, errbuf is filled in with an appropriate error message. errbuf is assumed to be able to hold at least PCAP_ERRBUF_SIZE chars.
pcap(3PCAP), pcap_activate_CREATE(3PCAP) | http://man7.org/linux/man-pages/man3/pcap_create.3pcap.html | CC-MAIN-2017-13 | en | refinedweb |
Created on 2015-11-10 07:16 by thehesiod, last changed 2016-02-10 22:39 by haypo. This issue is now closed.
asyncio.selector_events.BaseSelectorEventLoop._sock_connect_cb is a callback based on the selector for a socket. There are certain situations when the selector triggers twice calling this callback twice, resulting in an InvalidStateError when it sets the Future to None. The way I triggered this was by having several parallel connections to the same host in a multiprocessing script. I suggest analyzing why this callback can be called twice and figuring out what the correct fix is. I monkey patched it by adding a fut.done() check at the top. If this information is not enough I can try to provide a sample script. Its currently reproducing in a fairly involved multiprocessing script.
Please show us how to repro -- there's no way we can figure out how this "impossible" event could happen in your code without understanding your code. Is it possible that multiprocessing forked your event loop or something similarly esoteric?
Sorry for being obscure before, it was hard to pinpoint. I think I just figured it out! I had code like this in a subprocess:
def worker():
while True:
obj = self.queue.get()
# do work with obj using asyncio http module
def producer():
nonlocal self
obj2 = self.queue.get()
return obj2
workers = []
for i in range(FILE_OP_WORKERS):
t = asyncio.ensure_future(worker())
t.add_done_callback(op_finished)
workers.append(t)
while True:
f = loop.run_in_executor(None, producer)
obj = loop.run_until_complete(f)
t = async_queue.put(obj)
loop.run_until_complete(t)
loop.run_until_complete(asyncio.wait(workers))
where self.queue is a multiprocessing.Queue, and async_queue is an asyncio queue. The idea is that I have a process populating a multiprocessing queue, and I want to transfer it to an syncio queue while letting the workers do their thing.
Without knowing the underlying behavior, my theory is that when python blocks on the multiprocessing queue lock, it releases socket events to the async http module's selectors, and then when the async loop gets to the selectors they're released again.
If I switch the producer to instead use a queue.get_nowait and busy wait with asyncio.sleep I don't get the error...however this is not ideal is we're busy waiting.
Thanks!
I'm going to close this as I've found a work-around, if I find a better test-case I'll open a new bug.
Actually, I just realized I had fixed it locally by changing the callback to the following:
429 def _sock_connect_cb(self, fut, sock, address):
430 if fut.cancelled() or fut.done():
431 return
so a fix is still needed, and I also verified this happens with python3.4 as well.
clarification, adding the fut.done() check, or monkey patching:
orig_sock_connect_cb = asyncio.selector_events.BaseSelectorEventLoop._sock_connect_cb
def _sock_connect_cb(self, fut, sock, address):
if fut.done(): return
return orig_sock_connect_cb(self, fut, sock, address)
Sorry,.
self.queue is not an async queue, as I stated above its a multiprocessing queue. This code is to multiplex a multiprocessing queue to a async queue.
I.
Perhaps I'm doing something really stupid, but I was able to reproduce the two issues I'm having with the following sample script. If you leave the monkey patch disabled, you get the InvalidStateError, if you enable it, you get the ServerDisconnect errors that I'm currently seeing which I work-around with retries. Ideas?
import asyncio
import aiohttp
import multiprocessing
import aiohttp.server
import logging
import traceback
# Monkey patching
import asyncio.selector_events
#
if False:
orig_sock_connect_cb = asyncio.selector_events.BaseSelectorEventLoop._sock_connect_cb
def _sock_connect_cb(self, fut, sock, address):
if fut.done(): return
return orig_sock_connect_cb(self, fut, sock, address)
asyncio.selector_events.BaseSelectorEventLoop._sock_connect_cb = _sock_connect_cb
class HttpRequestHandler(aiohttp.server.ServerHttpProtocol):
@asyncio.coroutine
def handle_request(self, message, payload):
response = aiohttp.Response(self.writer, 200, http_version=message.version)
response.add_header('Content-Type', 'text/html')
response.add_header('Content-Length', '18')
response.send_headers()
yield from asyncio.sleep(0.5)
response.write(b'<h1>It Works!</h1>')
yield from response.write_eof()
def process_worker(q):
loop = asyncio.get_event_loop()
#loop.set_debug(True)
connector = aiohttp.TCPConnector(force_close=False, keepalive_timeout=8, use_dns_cache=True)
session = aiohttp.ClientSession(connector=connector)
async_queue = asyncio.Queue(100)
@asyncio.coroutine
def async_worker(session, async_queue):
while True:
try:
print("blocking on asyncio queue get")
url = yield from async_queue.get()
print("unblocking on asyncio queue get")
print("get aqueue size:", async_queue.qsize())
response = yield from session.request('GET', url)
try:
data = yield from response.read()
print(data)
finally:
yield from response.wait_for_close()
except:
traceback.print_exc()
def producer(q):
print("blocking on multiprocessing queue get")
obj2 = q.get()
print("unblocking on multiprocessing queue get")
print("get qempty:", q.empty())
return obj2
def worker_done(f):
try:
f.result()
print("worker exited")
except:
traceback.print_exc()
workers = []
for i in range(100):
t = asyncio.ensure_future(async_worker(session, async_queue))
t.add_done_callback(worker_done)
workers.append(t)
@asyncio.coroutine
def doit():
print("start producer")
obj = yield from loop.run_in_executor(None, producer, q)
print("finish producer")
print("blocking on asyncio queue put")
yield from async_queue.put(obj)
print("unblocking on asyncio queue put")
print("put aqueue size:", async_queue.qsize())
while True:
loop.run_until_complete(doit())
def server():
loop = asyncio.get_event_loop()
#loop.set_debug(True)
f = loop.create_server(lambda: HttpRequestHandler(debug=True, keep_alive=75), '0.0.0.0', '8080')
srv = loop.run_until_complete(f)
loop.run_forever()
if __name__ == '__main__':
q = multiprocessing.Queue(100)
log_proc = multiprocessing.log_to_stderr()
log_proc.setLevel(logging.DEBUG)
p = multiprocessing.Process(target=process_worker, args=(q,))
p.start()
p2 = multiprocessing.Process(target=server)
p2.start()
while True:
print("blocking on multiprocessing queue put")
q.put("")
print("unblocking on multiprocessing queue put")
print("put qempty:", q.empty())
I wonder if the bug is in aiohttp? The code you show is still too complex
to debug for me.
Attaching simplified test setup. It does take some doing to repro so the local async server is required to make it happen (for me). When I tried just pointing to python.org it would not repro in 100 iterations, but using a local dummy server repros 100% for me.
Attached server side of repro.
This code repros without aiohttp when pitted against the previously attached web server (again on OSX 10.11, mid-2012 MBPr).
Admittedly this may seem very arbitrary but I have better reasons in my production code for stopping an IOLoop and starting it again (which seems to be important to the reproduction steps).
import asyncio
loop = asyncio.get_event_loop()
def batch_open():
for i in range(100):
c = asyncio.ensure_future(asyncio.open_connection('127.0.0.1', 8080))
c.add_done_callback(on_resp)
def on_resp(task):
task.result()
loop.stop()
loop.call_soon(batch_open)
while True:
loop.run_forever()
Just reproduced on Linux, Fedora Core 23.
attaching my simplified testcase and logged an aiohttp bug:
Just.
Guido,
Shouldn't this not be the case for level triggered polling? From looking at selectors it looks like these are always level triggered which means they should only event once.
I'm not an expert on this terminology but don't you have that backwards?
Assume we're using select() for a second. If you ask select() "is this FD
ready" several times in a row without doing something to the FD it will
answer yes every time once the FD is ready. IIUC that's what
level-triggered means, and that's what causes the bug.
Nevermind, in the case of writeablity it won't matter either way.
--
So in looking at tornado's ioloop they run the ready callbacks before calling poll(). So the callbacks can modify the poll set.
I'm attaching a patch that runs `_ready` callbacks at the start of `_run_once`. The style and implications are ranging so I leave it to you at this point.
Thanks,.
I.
I.
Interesting.
I was going to do an analysis what using _ready.appendleft() for adding selector events would do for that scenario. The idea being to consistently juxtapose exiting callbacks, selector events and new callbacks. However I think this just moves the pawn in this ioloop halting problem.
Is it worth investigating a change to the stop mechanism instead? Instead of raising an exception in the middle of run_once, it could set a flag to be seen by run_forever(). This may avoid this class of problem altogether and ensure run_once is a fairly simple and predictable.
Yeah,()).
Yes,.
btw want to thank you guys for actively looking into this, I'm very grateful!
Thinking about this more I believe it's possible for any of the FD callbacks in selector_events.py to be placed into loop._ready multiple times if the loop is stopped after the FD is ready (and the callback is scheduled) but before the callback is called. In all cases such a scenario results in the same callback (with the same future) being scheduled twice; the first call will call fut.set_result() and then the second call, if the FD is (still, or again) ready, will fail calling fut.set_result() on the same Future.
The reason we've only seen reports of this for _sock_connect_cb() is probably that the other calls are all uncommon -- you have to explicitly call loop.sock_accept(), loop.sock_recv(), or loop.sock_sendall(), which is not the usual (or recommended) idiom. Instead, most people use Transports and Protocols, which use a different API, and create_server() doesn't use sock_accept(). But create_connection() *does* call sock_connect(), so that's used by everybody's code.
I think the discussed change to stop() to set a flag that is only checked after all the ready for-loop is done might work here -- it guarantees that all I/O callbacks get to run before the selector is polled again. However, it requires that an I/O callback that wants to modify the selector in order to prevent itself from being called must do so itself, not schedule some other call that modifies the selector. That's fine for the set of I/O callbacks I've looked at.
I just don't feel comfortable running the ready queue before polling the selector, since a worst-case scenario could starve the selector completely (as I sketched before -- and the proposed modification to stop() doesn't directly change this).
+1
Let me know what I can do to help.
@Justin: Do you want to come up with a PR for the stop() changes?
Hopefully including tests (I bet at least one test will fail -- our
tests in generally are pretty constraining).
On Mon, Nov 16, 2015 at 6:32 PM, Justin Mayfield <report@bugs.python.org> wrote:
>
> Justin Mayfield added the comment:
>
> +1
>
> Let me know what I can do to help.
>
> ----------
>
> _______________________________________
> Python tracker <report@bugs.python.org>
> <>
> _______________________________________
You bet.
Attached patch submission for stop flag proposal. I assume you didn't mean a github PR since the dev docs seem to indicate that is for readonly usage.
This passes all the tests on my osx box but it should obviously be run by a lot more folks.
I'm going to fix up the patch and apply it so this can make 3.5.1 rc1.
Here's a better patch.
- Renamed _stopped to _stopping.
- Restore test_utils.run_once() and add a test for it.
- Change logic so if _stopping is True upon entering run_forever(), it will run once.
Please try it out!!
Here's the file.
New patch. Update test_utils.run_once() to use the recommended idiom. On second thought I don't like issuing a warning when stop() is called before the loop runs -- a warning seems overkill for something so minor. But I'm okay with no longer recommending the idiom.
I.
Ha, email race.
Regarding rev 2, the updated docstring and scheduled stop looks good along with alleviating the confusion I mentioned.
I'm not sure about your warning comment; Perhaps that's a patch I didn't lay eyes on.
Cheers.
No, I mentioned the idea of a warning in the thread on the
python-tulip mailing list, but decided not to do it after all.
I see. Seems like good discussion over there. I joined up.
OK, here's another revision of the patch, setting the timeout passed to the selector to 0 when the loop is pre-stopped.
OK, another revision, keep the mock selector.
Whoops. Hopefully this one's right.
New changeset 9b3144716d17 by Guido van Rossum in branch '3.4':
Issue #25593: Change semantics of EventLoop.stop().
New changeset 158cc5701488 by Guido van Rossum in branch '3.5':
Issue #25593: Change semantics of EventLoop.stop(). (Merge 3.4->3.5)
New changeset 2ebe03a94f8f by Guido van Rossum in branch 'default':
Issue #25593: Change semantics of EventLoop.stop(). (Merge 3.5->3.6)
Hopefully this is it!
I'm not sure if you guys are still listening on this closed bug but I think I've found another issue ;) I'm using python 3.5.1 + asyncio 3.4.3 with the latest aiobotocore (which uses aiohttp 0.21.0) and had two sessions (two TCPConnectors), one doing a multitude of GetObjects via HTTP1.1, and the other doing PutObject, and the PutObject session returns error 61 (connection refused) from the same _sock_connect_cb. It feels like a similar issue to the original. I'll see if I can get small testcase.
update: its unrelated to the number of sessions or SSL, but instead to the number of concurrent aiohttp requests. When set to 500, I get the error, when set to 100 I do not.
Alex
sorry for disruption! ends up our router seems to be doing some kind of QoS limits on # of connections :( | https://bugs.python.org/issue25593 | CC-MAIN-2017-13 | en | refinedweb |
New Version Available: "RDF 1.1 Concepts and Abstract Syntax" (Document Status Update, 25 February 2014)
The RDF Working Group has produced a W3C Recommendation for a new version of RDF which adds features to this 2004 version, while remaining compatible. Please see "RDF 1.1 Concepts and Abstract Syntax" for a new version of this document, and the "What's New in RDF 1.1" document for the differences between this version of RDF and RDF 1.1. framework for representing information in the Web.
RDF Concepts and Abstract Syntax defines an abstract syntax on which RDF is based, and which serves to link its concrete syntax to its formal semantics. It also includes discussion of design goals, key concepts, datatyping, character normalization and handling of URI references., and the abstract syntax is defined in section 6 of this document.
Section.
RDF uses the following key concepts:").
Each triple represents a statement of a relationship between the things denoted by the nodes that it links. Each triple has three parts:
The direction of the arc is significant: it always points toward the object.
The nodes of an RDF graph are its subjects and objects.
The assertion of an RDF triple says that some relationship, indicated by the predicate, holds between the things denoted by subject and object of the triple. The assertion of an RDF graph amounts to asserting all the triples in it, so the meaning of an RDF graph is the conjunction (logical AND) of the statements corresponding to all the triples it contains. A formal account of the meaning of RDF graphs is given in [RDF-SEMANTICS].
A node may be a URI with optional fragment identifier (URI reference, or URIref), a literal, or blank (having no separate form of identification). Properties a predicate identifies a relationship between the things represented by the nodes it connects. A predicate, but has no intrinsic name..
Datatypes are used by RDF in the representation of values such as integers, floating point numbers and dates.
A datatype consists of a lexical space, a value space and a lexical-to-value mapping, see section 5.
For example, the lexical-to-value 5.1)..).I references to identify resources and properties. Certain URI references.
Vocabulary terms in the rdf: namespace are listed in section 5.1 of the RDF syntax specification [RDF-SYNTAX]. Some of these terms are defined by the RDF specifications to denote specific concepts. Others have syntactic purpose (e.g. rdf:ID is part of the RDF/XML syntax)., if there is a bijection M between the sets of nodes of the two graphs, such that:
With this definition, M shows how each blank node in G can be replaced with a new blank node to give G'.
A URI reference within an RDF graph (an RDF URI reference) is a Unicode string [UNICODE] that:
The encoding consists of:.
Note: The restriction to absolute URI references is found in this abstract syntax. When there is a well-defined base URI, concrete syntaxes, such as RDF/XML, may permit relative URIs as a shorthand for such absolute URI references.
Note: Because of the risk of confusion between RDF URI references that would be equivalent if derefenced, the use of %-escaped characters in RDF URI references is strongly discouraged. See also the URI equivalence issue of the Technical Architecture Group [TAG]..
Note: ill-formed.
Note: In application contexts, comparing the values of typed literals (see section 6.5.2) is usually more helpful than comparing their syntactic forms (see section 6.5.1). Similarly, for comparing RDF Graphs, semantic notions of entailment (see [RDF-SEMANTICS]) are usually more helpful than syntactic equality (see section 6.3).), i).
application/rdf+xmlis archived at .
There were no substantive changes.
The following editorial changes have been made: | http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/ | CC-MAIN-2017-13 | en | refinedweb |
I have a 3d numpy array describing a polycube (imagine a 3d tetris piece). How can I calculate all 24 rotations?
Numpy's array manipulation routines includes a rot90 method, which gives 4 of the 24, but I'm clueless how to calculate the rest. My only idea is to convert the 3d array to a 2d matrix of co-ordinates, multiply by a rotation matrix, and convert back. But I'd rather work directly with the 3d array.
Example 2x2x2 array:
>>> from numpy import array
>>> polycube
array([[[1, 0],
[1, 0]],
[[1, 1],
[0, 0]]])
array([[[1, 1, 0],
[1, 1, 0],
[0, 0, 0]],
[[0, 0, 0],
[1, 0, 0],
[1, 0, 0]],
[[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]])
So far I have 12 of them, composing
numpy.transpose to permute the axes (xyz, yzx, zxy—all the same handedness) and rot90.
def rotations12(polycube): for i in range(3): polycube = numpy.transpose(polycube, (1, 2, 0)) for angle in range(4): polycube = numpy.rot90(polycube) yield polycube
Quick test the 12 are distinct:
len(set(str(x) for x in rotations(polycube)))
Update: here's how I made all 24.
def rotations24(polycube): # imagine shape is pointing in axis 0 (up) # 4 rotations about axis 0 yield from rotations4(polycube, 0) # rotate 180 about axis 1, now shape is pointing down in axis 0 # 4 rotations about axis 0 yield from rotations4(rot90(polycube, 2, axis=1), 0) # rotate 90 or 270 about axis 1, now shape is pointing in axis 2 # 8 rotations about axis 2 yield from rotations4(rot90(polycube, axis=1), 2) yield from rotations4(rot90(polycube, -1, axis=1), 2) # rotate about axis 2, now shape is pointing in axis 1 # 8 rotations about axis 1 yield from rotations4(rot90(polycube, axis=2), 1) yield from rotations4(rot90(polycube, -1, axis=2), 1) def rotations4(polycube, axis): """List the four rotations of the given cube about the given axis.""" for i in range(4): yield rot90(polycube, i, axis)
Using this helper function generalising rot90 to rotate about any axis:
def rot90(m, k=1, axis=2): """Rotate an array by 90 degrees in the counter-clockwise direction around the given axis""" m = numpy.swapaxes(m, 2, axis) m = numpy.rot90(m, k) m = numpy.swapaxes(m, 2, axis) return m
I realise the helper function might not be quite right, but it worked
edit : correction in helper function m = numpy.rot90(m, k) | https://codedump.io/share/ZgBMoMY1TE3o/1/how-to-calculate-all-24-rotations-of-3d-array | CC-MAIN-2017-13 | en | refinedweb |
I introduced push as a concept in the last article, but I left a teaser – push to a subset of users with tags. Tags are really a meta-thing that equates to “interests”, but it’s really the way you would implement such things as “push-to-user” and “push-to-group”. They can literally be anything. Before I can get there, though, I need to be able to register for tags.
Dirty little secret – the current registration API allows you to request tags, but it actually ignores the tags. There is actually a good reason for this – if you allow the client to specify the tags, they may register for tags that they aren’t allowed to. For example, let’s say you implement a tag called “_email:”. Could a user register for a tag with someone elses email address by “hacking the REST request”. The answer, unfortunately, was yes. That could happen. Don’t let it happen to you.
Today I’m going to implement a custom API that replaces the regular push installations endpoint. My endpoint is going to define two distinct sets of tags – a whitelist of tags that the user can subscribe to (anything not an exact match in the list will be thrown out); and a set of dynamic tags based on the authentication record.
The Client
Before I can do anything, I need to be able to request tags. I’ve got an Apache Cordova app and can do requests for tags simply in the
register() method:
/** * Event Handler for response from PNS registration * @param {object} data the response from the PNS * @param {string} data.registrationId the registration Id from the PNS * @event */ function handlePushRegistration(data) { var pns = 'gcm'; var templates = { tags: ['News', 'Sports', 'Politics', '_email_myboss@microsoft.com' ] }; client.push.register(pns, data.registrationId, templates); }
The registration takes an object called “templates”, which contains the list of tags as an array. All the other SDKs have something similar to this. You will notice that I’ve got three tags that are “normal” and one that is special. I’m going to create a tag list that will strip out the ones I’m not allowed to have. For example, if I list ‘News’ and ‘Sports’ as valid tags, I expect the ‘Politics’ tag to be stripped out. In addition, the ‘_email’ tag should always be stripped out since it is definitely not mine.
Note that a tag cannot start with the $ sign – that’s a reserved symbol for Notification Hubs. Don’t use it.
The Node.js Version
The node.js version is relatively simple to implement, but I had to do some work to coerce the SDK to allow me to register a replacement for the push installations:
var express = require('express'), serveStatic = require('serve-static'), azureMobileApps = require('azure-mobile-apps'), authMiddleware = require('./authMiddleware'), customRouter = require('./customRouter'), pushRegistrationHandler = require('./pushRegistration'); // Set up a standard Express app var webApp = express(); // Set up the Azure Mobile Apps SDK var mobileApp = azureMobileApps({ notificationRootPath: '/.push/disabled' }); mobileApp.use(authMiddleware); mobileApp.tables.import('./tables'); mobileApp.api.import('./api'); mobileApp.use('/push/installations', pushRegistrationHandler);
Line 6 brings in my push registration handler. Line 13 moves the old push registration handler to “somewhere else”. Finally, line 19 registers my new push registration handler to take over the right place. Now, let’s look at the ‘./pushRegistration.js’ file:
var express = require('express'), bodyParser = require('body-parser'), notifications = require('azure-mobile-apps/src/notifications'), log = require('azure-mobile-apps/src/log'); module.exports = function (configuration) { var router = express.Router(), installationClient; if (configuration && configuration.notifications && Object.keys(configuration.notifications).length > 0) { router.use(addPushContext); router.route('/:installationId') .put(bodyParser.json(), put, errorHandler) .delete(del, errorHandler); installationClient = notifications(configuration.notifications); } return router; function addPushContext(req, res, next) { req.azureMobile = req.azureMobile || {}; req.azureMobile.push = installationClient.getClient(); next(); } function put(req, res, next) { var installationId = req.params.installationId, installation = req.body, tags = [], user = req.azureMobile.user; // White list of all known tags var whitelist = [ 'news', 'sports' ]; // Logic for determining the correct list of tags installations.tags.forEach(function (tag) { if (whitelist.indexOf(tag.toLowerCase()) !== -1) tags.push(tag.toLowerCase()); }); // Add in the "automatic" tags if (user) { tags.push('_userid_' + user.id); if (user.emailaddress) tags.push('_email_' + user.emailaddress); } // Replace the installation tags requested with my list installation.tags = tags; installationClient.putInstallation(installationId, installation, user && user.id) .then(function (result) { res.status(204).end(); }) .catch(next); } function del(req, res, next) { var installationId = req.params.installationId; installationClient.deleteInstallation(installationId) .then(function (result) { res.status(204).end(); }) .catch(next); } function errorHandler(err, req, res, next) { log.error(err); res.status(400).send(err.message || 'Bad Request'); } };
The important code here is in lines 33-50. Normally, the tags would just be dropped. Instead, I take the tags that are offered and put them through a whitelist filter. I then add on some more automatic tags (but only if the user is authenticated).
Note that this version was adapted from the Azure Mobile Apps Node.js Server SDK version. I’ve just added the logic to deal with the tags.
ASP.NET Version
The ASP.NET Server SDK comes with a built-in controller that I need to replace. It’s added to the application during the App_Start phase with this:
// Configure the Azure Mobile Apps section new MobileAppConfiguration() .AddTables( new MobileAppTableConfiguration() .MapTableControllers() .AddEntityFramework()) .MapApiControllers() .AddPushNotifications() /* Adds the Push Notification Handler */ .ApplyTo(config);
I can just comment the highlighted line out and the /push/installations controller is removed, allowing me to replace it. I’m not a confident ASP.NET developer – I’m sure there is a better way of doing this. I’ve found, however, that creating a Custom API and calling that custom API is a better way of doing the registration. It’s not a problem of the code within the controller. It’s a problem of routing. In my client, instead of calling
client.push.register(), I’ll call
client.invokeApi(). This version is in the Client.Cordova project:
/** * Event Handler for response from PNS registration * @param {object} data the response from the PNS * @param {string} data.registrationId the registration Id from the PNS * @event */ function handlePushRegistration(data) { var apiOptions = { method: 'POST', body: { pushChannel: data.registrationId, tags: ['News', 'Sports', 'Politics', '_email_myboss@microsoft.com' ] } }; var success = function () { alert('Push Registered'); } var failure = function (error) { alert('Push Failed: ' + error.message); } client.invokeApi("register", apiOptions).then(success, failure); }
Now I can write a POST handler as a Custom API in my backend:
using System.Web.Http; using Microsoft.Azure.Mobile.Server.Config; using System.Collections.Generic; using System.Net; using System.Net.Http; using System.Threading.Tasks; using System.Security.Principal; using Microsoft.Azure.Mobile.Server.Authentication; using System.Linq; using Microsoft.Azure.NotificationHubs; using System.Web.Http.Controllers; namespace backend.dotnet.Controllers { [Authorize] [MobileAppController] public class RegisterController : ApiController { protected override void Initialize(HttpControllerContext context) { // Call the original Initialize() method base.Initialize(context); } [HttpPost] public async Task<HttpResponseMessage> Post([FromBody] RegistrationViewModel model) { if (!ModelState.IsValid) { return new HttpResponseMessage(HttpStatusCode.BadRequest); } // We want to apply the push registration to an installation ID var installationId = Request.GetHeaderOrDefault("X-ZUMO-INSTALLATION-ID"); if (installationId == null) { return new HttpResponseMessage(HttpStatusCode.BadRequest); } // Determine the right list of tasks to be handled List<string> validTags = new List<string>(); foreach (string tag in model.tags) { if (tag.ToLower().Equals("news") || tag.ToLower().Equals("sports")) { validTags.Add(tag.ToLower()); } } // Add on the dynamic tags generated by authentication - note that the // [Authorize] tags means we are authenticated. var identity = await User.GetAppServiceIdentityAsync<AzureActiveDirectoryCredentials>(Request); validTags.Add($"_userid_{identity.UserId}"); var emailClaim = identity.UserClaims.Where(c => c.Type.EndsWith("emailaddress")).FirstOrDefault(); if (emailClaim != null) { validTags.Add($"_email_{emailClaim.Value}"); } // Register with the hub await CreateOrUpdatePushInstallation(installationId, model.pushChannel, validTags); return new HttpResponseMessage(HttpStatusCode.OK); } /// <summary> /// Update an installation with notification hubs /// </summary> /// <param name="installationId">The installation</param> /// <param name="pushChannel">the GCM Push Channel</param> /// <param name="tags">The list of tags to register</param> /// <returns></returns> private async Task CreateOrUpdatePushInstallation(string installationId, string pushChannel, IList<string> tags) { var pushClient = Configuration.GetPushClient(); Installation installation = new Installation { InstallationId = installationId, PushChannel = pushChannel, Tags = tags, Platform = NotificationPlatform.Gcm }; await pushClient.CreateOrUpdateInstallationAsync(installation); } } /// <summary> /// Format of the registration view model that is passed to the custom API /// </summary> public class RegistrationViewModel { public string pushChannel; public List<string> tags; } }
The real work here is done by the
CreateOrUpdatePushInstallation() method at lines 77-84. This uses the Notification Hub SDK to register the device according to my rules. Why write it as a Custom API? Well, I need things provided by virtue of the
[MobileApiController] attribute – things like the notification hub that is linked and authentication. However, doing that automatically links the controller into the
/api namespace, thus overriding my intent of replacing the push installation version. There are ways of discluding the association, but is it worth the effort? My thought is no, which is why I switched over to a Custom API. I can get finer control over the invokeApi rather than worry about whether the Azure Mobile Apps SDK is doing something wierd.
Wrap Up
I wanted to send two important messages here. Firstly, use the power of Notification Hubs by taking charge of the registration process yourself. Secondly, do the logic in the server – not the client. It’s so tempting to say “just do what my client says”, but remember rogue operators don’t think that way – you need to protect the services that you pay for so that only you are using them and you can only effectively do that from the server.
Next time, I’ll take a look at a common pattern for push that will improve the offline performance of your application. Until then, you can find the code on my GitHub Repository.
2 thoughts on “30 Days of Zumo.v2 (Azure Mobile Apps): Day 24 – Push with Tags”
[…] 30 Days of Zumo.v2 (Azure Mobile Apps): Day 24 – Push with Tags (Adrian Hall) […]
[…] 30 Days of Zumo.v2 (Azure Mobile Apps): Day 24 – Push with Tags by Adrian Hall […] | https://shellmonger.com/2016/05/23/30-days-of-zumo-v2-azure-mobile-apps-day-24-push-with-tags/ | CC-MAIN-2017-13 | en | refinedweb |
Key updates include: Jupyter notebook integration, movie recording capabilities, time series animation, updated VTK compatibility, and Python 3 support
by Prabhu Ramachandran, core developer of Mayavi and director, Enthought India
The Mayavi development team is pleased to announce Mayavi 4.5.0, which is an important release both for new features and core functionality updates.
Mayavi is a general purpose, cross-platform Python package for interactive 2-D and 3-D scientific data visualization. Mayavi integrates seamlessly with NumPy (fast numeric computation library for Python) and provides a convenient Pythonic wrapper for the powerful VTK (Visualization Toolkit) library. Mayavi provides a standalone UI to help visualize data, and is easy to extend and embed in your own dialogs and UIs. For full information, please see the Mayavi documentation.
Mayavi is part of the Enthought Tool Suite of open source application development packages and is available to install through Enthought Canopy’s Package Manager (you can download Canopy here).
Mayavi 4.5.0 is an important release which adds the following features:
- Jupyter notebook support: Adds basic support for displaying Mayavi images or interactive X3D scenes
- Support for recording movies and animating time series
- Support for the new matplotlib color schemes
- Improvements on the experimental Python 3 support from the previous release
- Compatibility with VTK-5.x, VTK-6.x, and 7.x. For more details on the full set of changes see here.
Let’s take a look at some of these new features in more detail:
Jupyter Notebook Support
This feature is still basic and experimental, but it is convenient. The feature allows one to embed either a static PNG image of the scene or a richer X3D scene into a Jupyter notebook. To use this feature, one should first initialize the notebook with the following:
from mayavi import mlab
mlab.init_notebook()
Subsequently, one may simply do:
s = mlab.test_plot3d()
s
This will embed a 3-D visualization producing something like this:
When the init_notebook method is called it configures the Mayavi objects so they can be rendered on the Jupyter notebook. By default the init_notebook function selects the X3D backend. This will require a network connection and also reasonable off-screen support. This currently will not work on a remote Linux/OS X server unless VTK has been built with off-screen support via OSMesa as discussed here.
For more documentation on the Jupyter support see here.
Animating Time Series
This feature makes it very easy to animate a time series. Let us say one has a set of files that constitute a time series (files of the form some_name[0-9]*.ext). If one were to load any file that is part of this time series like so:
from mayavi import mlab
src = mlab.pipeline.open('data_01.vti')
Animating these is now very easy if one simply does the following:
src.play = True
This can also be done on the UI. There is also a convenient option to synchronize multiple time series files using the “sync timestep” option on the UI or from Python. The screenshot below highlights the new features in action on the UI:
Recording Movies
One can also create a movie (really a stack of images) while playing a time series or running any animation. On the UI, one can select a Mayavi scene and navigate to the movie tab and select the “record” checkbox. Any animations will then record screenshots of the scene. For example:
from mayavi import mlab
f = mlab.figure()
f.scene.movie_maker.record = True
mlab.test_contour3d_anim()
This will create a set of images, one for each step of the animation. A gif animation of these is shown below:
More than 50 pull requests were merged since the last release. We are thankful to Prabhu Ramachandran, Ioannis Tziakos, Kit Choi, Stefano Borini, Gregory R. Lee, Patrick Snape, Ryan Pepper, SiggyF, and daytonb for their contributions towards this release.
Additional Resources on Mayavi:
- Mayavi documentation / user guide
- Mayavi example gallery
- SciPy lecture notes, Advanced 3-D Plotting with Mayavi, by Gaël Varoquaux
- Using Mayavi with SciPy: a Tutorial , by Gaël Varoquaux | http://blog.enthought.com/general/mayavi-python-3d-data-visualization-and-plotting-library-adds-major-new-features-in-recent-release/ | CC-MAIN-2017-13 | en | refinedweb |
Say for example in this program I intend to get the sum of the elements in an array. I know it's possible with only one method but for learning's sake, lets say I'd use another method. So far I've got this:
import java.util.Random; public class Main { public static void main(String args[]){ Random Rand = new Random(); int arNum[] = new int[10]; int ctr=0; int Answer; for(ctr=0;ctr<10;ctr++){ arNum[ctr] = ((Rand.nextInt(6)) + 1); } Answer = getSum(arNum[ctr]); } public static int getSum(int x[]){ int count=0; int sum = 0; for(count=0;count<=x.length;count++){ sum += x[count]; } return sum; } }
Now the error is here:
Answer = getSum(arNum[ctr]);
Why doesn't that work?
| http://www.dreamincode.net/forums/topic/313740-simple-question-about-arrays-in-methods/ | CC-MAIN-2017-13 | en | refinedweb |
Download presentation
Presentation is loading. Please wait.
Published byJennifer Doar Modified over 2 years ago
2
The campus of the School of Hard Knocks is in the far country (Proverbs 13:15). The Prodigal Son had a difficult curriculum. Course in Economics - and when he had spent all (Luke 15:14). Course in Horticulture - there arose a mighty famine in that land (Luke 15:14) Course in Livestock Management - he sent him into the field to feed swine (Luke 15:15) Course in Sociology - and no man gave unto him(Luke 15:16; Proverbs 14:20; Proverbs 19:6)
3
You smell terrible. You look awful. You have been working a disgraceful job. You have disgraced your fathers name. He wont take you back!! Luke 15:15 - And he went and joined himself to a citizen of that country. Joined himself- To glue or cement, this implies that he forced himself upon the citizen. He only took him into service because he constantly entreated him for work.
4
The Course in Theology - (Proverbs 22:6). The livestock owner did not know the prodigals father. This is the course that the young man remembered, Luke 15:17 And when he came to himself. How many hired servants of my fathers have bread enough and to spare (Luke 15:17).
5
Ephesians 1:3 – Blessed be the God and Father of our Lord Jesus Christ, who hath blessed us with all spiritual blessing in heavenly places in Christ
6
The Location- In Christ! In order to receive blessings from God, one must be in Christ, the body, the church, the house of God. The prodigal had no blessings away from the Fathers house (Luke 15:17). The Origin Of Gods Blessing- The heavenly places ( literal the heavenlies). The blessings of God do not originate from man, nor can they be disseminated at mans direction. They are Gods blessings to give as God sees fit (Daniel 4:35).
7
The Nature Of Gods Blessings - Spiritual! Physical blessings are promised by God (Matthew 6:25-34), but the bread that truly matters is that which feed and nourishes the soul, preparing for eternity. The Distribution of Gods Blessings - All or Every. Not a single spiritual blessing from the heavenlies can be enjoyed outside of Christ. If one is not in Christ, there are absolutely zero spiritual blessings promised to him.
8
Matthew 14: 19- 21 Mark 8: 19-21 Ephesians 3: 20-21 Psalm 50:10-12- For every beast of the field is mine, and the cattle upon a thousand hills. I know all the fowls of the mountains: and the wild beasts of the field are mine. If I were hungry, I would not tell thee: for the world is mine, and the fullness thereof.
9
Luke 15:20- The first emotion that the father felt was compassion. The Greek is far more expressive than the English. Literally the father hugged him down. In other words the father embraced his son with such emotion that they both went to the ground. Then the father kissed him again and again.
10
The speech- Luke 15: 18-19. The young man did not complete the rehearsed speech. He only made it through repentance. Luke 15:21- And the son said unto him, Father, I have sinned against heaven, and in thy sight, and am no more worthy to be called thy son. What about make me as one of your hired servants?
11
The father cut off the speech. The young man got through repentance but not the request. In the far country the prodigal learned the meaning of misery, but back at his fathers house he discovered, the meaning of mercy. Where does the Father go from here?
12
Best Robe- A fine stately garment that came down to the feet. It was the kind of robe worn by kings. The robe was a gift of identity. He came home wearing clothes that identified him with failure. Sin leaves identifying marks on our lives (Luke 15:14-16; Zechariah 3:3-4) Matthew 22:11- The man wanted to be a part of the feast but his garments betrayed him.
13
The ring- The ring bore the family emblem or name. It was pressed in wax to seal letters and legal documents. The ring was a gift of authority. The ring signified that he was back in authority in the Fathers business. Everyone would have to answer to the Father if they disrespected the sons portion.
14
The shoes- Sandals were a clear indication that the prodigal son was not going to be a servant. Servants nor slaves wore sandals. The shoes were a gift of ability. More is expected of you when you have more. (Matthew 25:15) The fatted calf- The calf was fed with wheat and kept for festive celebrations. The Father is waiting for us to return (2 Peter 3:9).
15
Clothes- Robe Jewelry- Ring Friends- Servants Joyful Celebration- The feast Love - The Father. We love him because he first loved us. Assurance of the future- Inheritance. He was back in the Fathers business.
Similar presentations
© 2017 SlidePlayer.com Inc. | http://slideplayer.com/slide/1471036/ | CC-MAIN-2017-13 | en | refinedweb |
Posted 25 Sep 2015
Link to this post
Hello,
In the document found on Telerik (), it shows the ActiveWorksheet has a ViewState property, however I do not find that.
I am using the Workbook class found in the namespace Telerik.Windows.Documents.Spreadsheet.Model. It is my understanding that this is the correct Namespace / DLL(s) to use for processing spreadsheets.
Your help is appreciated,
Chris
Posted 29 Sep 2015
Link to this post
WorksheetViewStateworksheetViewState = (WorksheetViewState)((ISheet)workbook.ActiveWorksheet).ViewState;
Panepane = new Pane(new CellIndex(17, 4), 3, 5, ViewportPaneType.Scrollable);
worksheetViewState.Pane = | http://www.telerik.com/forums/using-freeze-panes | CC-MAIN-2017-13 | en | refinedweb |
Take any modern web page and you will notice that it invariably contains content stitched together from a variety of different sources; it may include the social sharing widgets from Twitter or Facebook or a Youtube video playing widget, it may serve a personalized advertisement from some ad-server or it may include some utility scripts or styles from a third party library hosted over CDN and so on. And if everything is HTML based (as is preferred these days) there is a high probability of collisions between the markup, scripts or styles served from various sources. Generally, namespaces are employed to prevent these collisions which solve the problem to some extent, but they don't offer Encapsulation.
Encapsulation is one of the pillars on which the Object Oriented Programming paradigm was founded and is normally used to restrict the internal representation of an object from the outside world.
Coming back to our problem, we can surely encapsulate the JavaScript code using closures or using the module pattern but can we do the same for our HTML markup? Imagine that we have to build a UI widget, can we hide the implementation details of our widget from the JavaScript and CSS code that is included on the page, which consumes our widget? Alternatively, can we prevent the consuming code from messing up our widget's functionality or look and feel?
Shadow DOM to the Rescue
The only existing solution that creates a boundary between the code you write and code that consumes, is ugly - and operates by using a bulky and restrictive iFrame, which brings with itself another set of problems. So are we forced to adapt to this approach always?
Not anymore! Shadow DOM provides us an elegant way to overlay the normal DOM subtree with a special document fragment that contains another subtree of nodes, which are impregnable to scripts and styles. The interesting part is that it's not something new! Various browsers have already been using this methodology to implement native widgets like date, sliders, audio, video players, etc.
Enabling Shadow DOM
At the time of this writing, the current version of Chrome (v29) supports inspecting Shadow DOM using Chrome DevTools. Open Devtools and click on the cog button at the bottom right of the screen to open the Settings panel, scroll down a bit and you will see a checkbox for showing Shadow DOM.
Now that we have enabled our browser, lets check out the internals of the default audio player. Just type:
<audio width="300" height="32" src="" autoplay="autoplay" controls="controls"> Your browser does not support the HTML5 Audio. </audio>
Into your HTML markup. It shows the following native audio player in supported browsers:
Now go ahead and inspect the audio player widget that you just created.
Wow! It shows the internal representation of the audio player, which was otherwise hidden. As we can see, the audio element uses a document fragment to hold the internal contents of the widget and appends that to the container element ( which is known as Shadow Host ).
Shadow Host & Shadow Root
- Shadow Host: is the DOM element which is hosting the
Shadow DOMsubtree or it is the DOM node which contains the Shadow Root.
- Shadow Root: is the root of the DOM subtree containing the shadow DOM nodes. It is a special node, which creates the boundary between the normal DOM nodes and the Shadow DOM nodes. It is this boundary, which encapsulates the Shadow DOM nodes from any JavaScript or CSS code on the consuming page.
- Shadow DOM: allows for multiple DOM subtrees to be composed into one larger tree. Following images from the W3C working draft best explains the concept of overlaying the nodes. This is how it looks before the Shadow Root's content are attached to Shadow Host element:
When rendered, the Shadow tree takes place of Shadow Host's content.
This process of overlaying the nodes is often referred to as Composition.
- Shadow Boundary: is denoted by the dotted line in the image above. This denotes the separation between the normal DOM world and the Shadow DOM world. The scripts from either side cannot cross this boundary and create havoc on the other side.
Hello Shadow DOM World
Enough chit-chat I say, Let's get our hands dirty by writing some code. Suppose we have the following markup, which shows a simple welcome message.
<div id="welcomeMessage">Welcome to My World</div>
Add the following JavaScript code or use this Fiddle:
var shadowHost = document.querySelector("#welcomeMessage"); var shadowRoot = shadowHost.webkitCreateShadowRoot(); shadowRoot.textContent = "Hello Shadow DOM World";
Here we create a Shadow Root using the
webkitCreateShadowRoot() function, attach it to a Shadow Host and then simply change the content.
Notice the vendor-specific prefix
webkit before the function name. This indicates that this functionality is currently supported on some webkit-based browsers only.
If you go ahead and run this example in a supported browser, then you would see "Hello Shadow DOM World" instead of "Welcome to My World" as the Shadow DOM nodes have over-shadowed the normal ones.
Disclaimer: As some of you may notice, we're mixing the markup with scripts, which is generally not recommended and Shadow DOM is no exception. We have deliberately avoided the use of templates so early in the game in order to avoid any confusion. Otherwise Shadow DOM does provide an elegant solution to this problem and we will get there pretty soon.
Respecting Shadow Boundary
If you try and access the content of the rendered tree using JavaScript, like so:
var shadowHost = document.querySelector("#welcomeMessage"); var shadowRoot = shadowHost.webkitCreateShadowRoot(); shadowRoot.textContent = "Hello Shadow DOM World"; console.log(shadowHost.textContent); // Prints "Welcome to My World" as the shadow DOM nodes are encapsulated and cannot be accessed by JavaScript
You will get the original content "Welcome to My World" and not the content which is actually rendered on the page, as the Shadow DOM tree is encapsulated from any scripts. This also means that the widget that you create using Shadow DOM is safe from any unwanted/conflicting scripts already present in the page.
Styles Encapsulation
Similarly, any CSS selector is forbidden to cross the shadow boundary. Check the following code where we have applied red color to the list items, but that style is only applied to the nodes which are part of the parent page, and the list items which are part of Shadow Root are not affected with this style.
<div class="outer"> <div id="welcomeMessage">Welcome to My World</div> <div class="normalTree">Sample List <ul> <li>Item 1</li> <li>Item 2</li> </ul> </div> </div> <style> div.outer li { color: red; } div.outer{ border: solid 1px; padding: 1em; } </style> <script type="text/javascript"> var shadowHost = document.querySelector("#welcomeMessage"); var shadowRoot = shadowHost.webkitCreateShadowRoot(); shadowRoot.innerHTML = ["<div class='shadowChild'>", "Shadow DOM offers us Encapsulation from", "<ul>", "<li>Scripts</li>", "<li>Styles</li>", "</ul>", "</div>" ].join(',').replace(/,/g,""); </script>
You can see the code in action on Fiddle. This encapsulation applies even if we reverse the direction of traversal. Any styles which are defined inside the Shadow DOM does not affect the parent document and remains scoped to the Shadow Root only. Check this Fiddle for an example, where we apply the blue color to list items in Shadow DOM but the parent document's list items are unaffected.
There is however one notable exception here; Shadow DOM gives us the flexibility to style the Shadow Host, the DOM node which is holding the Shadow DOM. Ideally it lies outside the Shadow boundary and is not a part of Shadow Root, but using the
@host rule, one can specify the styles that can be applied to Shadow Host as we have styled the welcome message in the example below.
<div id="welcomeMessage">Welcome to My World</div> <script type="text/javascript"> var shadowHost = document.querySelector("#welcomeMessage"); var shadowRoot = shadowHost.webkitCreateShadowRoot(); shadowRoot.innerHTML = ["<style>", "@host{ ", "#welcomeMessage{ ", "font-size: 28px;", "font-family:cursive;", "font-weight:bold;", "}", "}", "</style>", "<content select=''></content>" ].join(',').replace(/,/g,""); </script>
Check this Fiddle as we style the Shadow Host's welcome message using the styles defined in Shadow DOM.
Creating Style Hooks
As a widget developer, I might want the user of my widget to be able to style certain elements. This is achievable by plugging a hole into the shadow boundary using custom pseudo elements. This is similar to how some browsers create style hooks for the developer to style some internal elements of a native widget. For example, to style the thumb and the track of the native slider you can use the
::-webkit-slider-thumb and
::webkit-slider-runnable-track as follows:
input[type=range]{ -webkit-appearance:none; } input[type=range]::-webkit-slider-thumb { -webkit-appearance:none; height:12px; width:12px; border-radius:6px; background:yellow; position:relative; top:-5px; } input[type=range]::-webkit-slider-runnable-track { background:red; height:2px; }
Fork this Fiddle and apply your own styles to it!
Event Re-Targeting
If an event that originates from one of the nodes in Shadow DOM crosses the Shadow Boundary then it is re-targeted to refer to the Shadow Host in order to maintain encapsulation. Consider the following code:
<input id="normalText" type="text" value="Normal DOM Text Node" /> <div id="shadowHost"></div> <input id="shadowText" type="text" value="Shadow DOM Node" /> <script type="text/javascript"> var shadowHost = document.querySelector('#shadowHost'); var shadowRoot = shadowHost.webkitCreateShadowRoot(); var template = document.querySelector('template'); shadowRoot.appendChild(template.content.cloneNode(true)); template.remove(); document.addEventListener('click', function(e) { console.log(e.target.id + ' clicked!'); }); </script>
It renders two text input elements, one via Normal DOM and another via Shadow DOM and then listens for a
click event on the
document. Now, when the second text input is clicked, the event is originated from inside Shadow DOM and when it crosses the Shadow Boundary, the event is modified to change the target element to Shadow Host's
<div> element instead of the
<input> text input. We have also introduced a new
<template> element here; this is conceptually similar to client-side templating solutions like Handlebars and Underscore but is not as evolved and lacks browser support. Having said that, using templates is the ideal way to write Shadow DOM rather than using script tags as has been done so far throughout this article.
Separation of Concerns
We already know that it's always a good idea to separate actual content from presentation; Shadow DOM should not embed any content, which is to be finally shown to the user. Rather, the content should always be present on the original page and not hidden inside the Shadow DOM template. When the composition occurs, this content should then be projected into appropriate insertion points defined in the Shadow DOM's template. Let's rewrite the Hello World example, keeping in mind the above separation - a live example can be found on Fiddle.
<div id="welcomeMessage">Welcome to Shadow DOM World</div> <script type="text/javascript"> var shadowRoot = document.querySelector("#welcomeMessage").webkitCreateShadowRoot(); var template = document.querySelector("template"); shadowRoot.appendChild(template.content); template.remove(); </script>
When the page is rendered, the content of the Shadow Host is projected into the place where the
<content> element appears. This is a very simplistic example where
<content> picks up everything inside the Shadow Host during composition. But it can very well be selective in picking the content from Shadow Host using the
select attribute as shown below
<div id="outer">How about some cool demo, eh ? <div class="cursiveButton">My Awesome Button</div> </div> <button> Fallback Content </button> <style> button{ font-family: cursive; font-size: 24px; color: red; } </style> <script type="text/javascript"> var shadowRoot = document.querySelector("#outer").webkitCreateShadowRoot(); var template = document.querySelector("template"); shadowRoot.appendChild(template.content.cloneNode(true)); template.remove(); </script>
Check out the live demo and play with it to better understand the concept of insertion points and projections.
Web Components
As you may already know, Shadow DOM is a part of the Web Components Spec, which offers other neat features, like:
- Templates - are used to hold inert markup, which is to be used at a later point in time. By inert, we mean that all the images in the markup are not downloaded, scripts included are not present until the content of the template actually becomes a part of the page.
- Decorators - are used to apply the templates based on CSS Selectors and hence can be seen as decorating the existing elements by enhancing their presentation.
- HTML Imports - provides us with the capability to reuse other HTML documents in our document without having to explicitly make XHR calls and write event handlers for it.
- Custom Elements - allows us to define new HTML element types which can then be used declaratively in the markup. For example, if you want to create your own navigation widget, you define your navigation element, inheriting from HTMLElement and providing certain life-cycle callbacks which implement certain events like construction, change, destruction of the widget and simply use that widget in your markup as
<myAwesomeNavigation attr1="value1"..></myAwesomeNavigation>. So custom elements essentially give us a way to bundle all the Shadow DOM magic, hiding the internal details and packages everything together.
I wont babble much about other aspects of the Web Components Spec in this article but it would do us good to remember that together they enable us to create re-usable UI widgets which are portable across browsers in look and feel and fully encapsulated by all the scripts and styles of the consuming page.
Conclusion
The Web Components Spec is a work in progress and the sample code included which works today may not work on a later release. As an example, earlier texts on this subject use the
webkitShadowRoot() method which no longer works; Instead use
createWebkitShadowRoot() to create a Shadow Root. So if you want to use this to create some cool demos using Shadow DOM, it's always best to refer to the spec for details.
Currently, only Chrome and Opera supports it so I would be wary about including any Shadow DOM on my production instance, but with Google coming out with Polymer which is built on top of Web Components and Polyfills coming out to support Shadow DOM natively, this is surely something that every web developer must get his hands dirty with.
You can also stay updated with the latest happenings on Shadow DOM by following this Google+ Channel. Also checkout the Shadow DOM Visualizer tool, which helps you to visualize how Shadow DOM renders in the browser.
Envato Tuts+ tutorials are translated into other languages by our community members—you can be involved too!Translate this post
| https://code.tutsplus.com/tutorials/intro-to-shadow-dom--net-34966?utm_source=CSS-Weekly&utm_campaign=Issue-91&utm_medium=web | CC-MAIN-2017-13 | en | refinedweb |
Unlocking ES2015 features with Webpack and Babel
This post is part of a series of ES2015 posts. We'll be covering new JavaScript functionality every week for the coming two months.
After being in the working draft state for a long time, the ES2015 (formerly known as ECMAScript 6 or ES6 shorthand) specification has reached a definitive state a while ago. For a long time now, BabelJS, a Javascript transpiler, formerly known as 6to5, has been available for developers that would already like to use ES2015 features in their projects.
In this blog post I will show you how you can integrate Webpack, a Javascript module builder/loader, with Babel to automate the transpiling of ES2015 code to ES5. Besides that I'll also explain you how to automatically generate source maps to ease development and debugging.
Webpack
Introduction
Webpack is a Javascript module builder and module loader. With Webpack you can pack a variety of different modules (AMD, CommonJS, ES2015, ...) with their dependencies into static file bundles. Webpack provides you with loaders which essentially allow you to pre-process your source files before requiring or loading them. If you are familiar with tools like Grunt or Gulp you can think of loaders as tasks to be executed before bundling sources. To make your life even easier, Webpack also comes with a development server with file watch support and browser reloading.
Installation
In order to use Webpack all you need is npm, the Node Package Manager, available by downloading either Node or io.js. Once you've got npm up and running all you need to do to setup Webpack globally is install it using npm:
npm install -g webpack
Alternatively, you can include it just in the projects of your preference using the following command:
npm install --save-dev webpack
Babel
Introduction
With Babel, a Javascript transpiler, you can write your code using ES2015 (and even some ES7 features) and convert it to ES5 so that well-known browsers will be able to interpret it. On the Babel website you can find a list of supported features and how you can use these in your project today. For the React developers among us, Babel also comes with JSX support out of the box.
Alternatively, there is the Google Traceur compiler which essentially solves the same problem as Babel. There are multiple Webpack loaders available for Traceur of which traceur-loader seems to be the most popular one.
Installation
Assuming you already have npm installed, installing Babel is as easy as running:
npm install --save-dev babel-loader
This command will add babel-loader to your project's package.json. Run the following command if you prefer installing it globally:
npm install -g babel-loader
Project structure
webpack-babel-integration-example/ src/ DateTime.js Greeting.js main.js index.html package.json webpack.config.js
Webpack's configuration can be found in the root directory of the project, named webpack.config.js. The ES6 Javascript sources that I wish to transpile to ES5 will be located under the src/ folder.
Webpack configuration
The Webpack configuration file that is required is a very straightforward configuration or a few aspects:
- my main source entry
- the output path and bundle name
- the development tools that I would like to use
- a list of module loaders that I would like to apply to my source
var path = require('path'); module.exports = { entry: './src/main.js', output: { path: path.join(__dirname, 'build'), filename: 'bundle.js' }, devtool: 'inline-source-map', module: { loaders: [ { test: path.join(__dirname, 'src'), loader: 'babel-loader' } ] } };
The snippet above shows you that my source entry is set to src/main.js, the output is set to create a build/bundle.js, I would like Webpack to generate inline source maps and I would like to run the babel-loader for all files located in src/.
ES6 sources
A simple ES6 class
Greeting.js contains a simple class with only the
toString method implemented to return a String that will greet the user:
class Greeting { toString() { return 'Hello visitor'; } } export default Greeting
Using packages in your ES2015 code
Often enough, you rely on a bunch of different packages that you include in your project using npm. In my example, I'll use the popular date time library called Moment.js. In this example, I'll use Moment.js to display the current date and time to the user.
Run the following command to install Moment.js as a local dependency in your project:
npm install --save-dev moment
I have created the DateTime.js class which again only implements the
toString method to return the current date and time in the default date format.
import moment from 'moment'; class DateTime { toString() { return 'The current date time is: ' + moment().format(); } } export default DateTime
After importing the package using the import statement you can use it anywhere within the source file.
Your main entry
In the Webpack configuration I specified a src/main.js file to be my source entry. In this file I simply import both classes that I created, I target different DOM elements and output the
toString implementations from both classes into these DOM objects.
import Greeting from './Greeting.js'; import DateTime from './DateTime.js'; var h1 = document.querySelector('h1'); h1.textContent = new Greeting(); var h2 = document.querySelector('h2'); h2.textContent = new DateTime();
HTML
After setting up my ES2015 sources that will display the greeting in an h1 tag and the current date time in an h2 tag it is time to setup my index.html. Being a straightforward HTML-file, the only thing that is really important is that you point the script tag to the transpiled bundle file, in this example being build/bundle.js.
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Webpack and Babel integration example</title> </head> <body> <h1></h1> <h2></h2> <script src="build/bundle.js"></script> </body> </html>
Running the application
In this example project, running my application is as simple as opening the index.html in your favorite browser. However, before doing this you will need to instruct Webpack to actually run the loaders and thus transpile your sources into the build/bundle.js required by the index.html.
You can run Webpack in watch mode, meaning that it will monitor your source files for changes and automatically run the module loaders defined in your configuration. Execute the following command to run in watch mode:
webpack --watch
If you are using my example project from Github (link at the bottom), you can also use the following script which I've set up in the package.json:
npm run watch
Easier debugging using source maps
Debugging transpiled ES5 is a huge pain which will make you want to go back to writing ES5 without thinking. To ease development and debugging of ES2015 I can rely on source maps generated by Webpack. While running Webpack (normal or in watch mode) with the devtool property set to inline-source-map you can view the ES2015 source files and actually place breakpoints in them using your browser's development tools.
Running the example project with a breakpoint inside the DateTime.js
toString method using the Chrome developer tools.
Conclusion
As you've just seen, setting up everything you need to get started with ES2015 is extremely easy. Webpack is a great utility that will allow you to easily set up your complete front-end build pipeline and seamlessly integrates with Babel to include code transpiling into the build pipeline. With the help of source maps even debugging becomes easy again.
Sample project
The entire sample project as introduced above can be found on Github.
Thank you very much for this wonderful guide! Worked perfectly for me.
Great tutorial. Thanks. I've been learning webpack and babel. However, with all kinds of other tools to fiddle with (gulp, browserify, angular, react, typescript etc.) I've had some trouble figuring out the minimal set of babel-XXX npm packages I needed to get a simple es6 file working. Your tutorial gave me exactly what I needed. However, now that babel has been upgraded from v5 to v6 your tutorial and your github site need some slight updates. Specifically, this project requires `npm install --save-dev babel-core babel-preset-es2015` (in addition to `babel-loader`) and requires a `.babelrc` file that contains `{"presets": ["es2015"]}`. BTW, for your own info, note that I found your tutorial because it's listed on the official webpack site on its list of tutorials (). | http://blog.xebia.com/unlocking-es2015-features-with-webpack-and-babel/ | CC-MAIN-2017-13 | en | refinedweb |
Interview Update With Bjarne Stroustrup On C++0x 589
An anonymous reader writes "DevX interviewed Bjarne Stroustrup about C++0x, the new C++ standard that is due in 2009. Bjarne Stroustrup has classified the new features into three categories: Concurrency, Libraries and Language. The changes introduced in Concurrency makes C++ more standardized and easy to use on multi-core processors. It is good to see that some of the commonly used libraries are becoming standard (eg: unordered_maps and regex)."
Nice name, chief. (Score:5, Funny)
I saw the headline and thought I was seeing some 1337 form of "cox."
huhuhuuhuhuh he said "form."
C#++? (Score:3, Funny)
Re:C#++? (Score:5, Insightful)
Because performance is important to some people.
Re:C#++? (Score:5, Insightful)
If it was as good as it stands, then newer languages such as C# wouldn't take off.
Don't get me wrong, I love C++ and it's my primary programming language, but to say it's perfect as it is, is just silly.
Re: (Score:3, Insightful)
The day when McDonalds can get away with requiring MS CS, MS EE, AND get an abundance of qualified applicants for fry cook positions is rapidly approaching.
Goodbye helloworld.c, hello wantfrieswiththat.cxx
Re:C#++? (Score:4, Insightful)
"MBA's will not need programmers anymore, so we'll be able to code OSS full time!"
You realize that is what they said when they introduced COBOL, right?
Re:C#++? (Score:5, Insightful)
Re:C#++? (Score:4, Insightful)
If you make language even an idiot can use, idiots will be using it. Like with VB.
So lets make the language as difficult as possible. That way only good programmers will even be able to write code in it. Never mind the fact that they'll have to spend all their mental effort getting the code to work instead of focusing on the problem they're trying to solve.
The fact that an easy versatile language makes it easy for idiots to program in it is no reason to artificially make a language overly complex. That's insane. It's like making a hammer that requires a PhD to use just to prevent bad handymen from doing handywork.
In other words plenty of good code was written in VB by non-idiots who didn't want to focus on the language but had a practical problem to solve. You can leave the morons to survival of the fittest.
Re: (Score:3, Insightful)
Well that's just it, C++ is designed to be as general a language as you can manage (which is why so many people don't "get" it or complain that it's complicated because not much is done for you in comparison to other languages) which is why other languages may be better suited to certain tasks.
The example you gave for C# is a pretty good one, but it still highlights that there are areas where C++ isn't well suited to certain tasks and until it is, it's fair to say there's room for improvement.
Thus I welcome
Re:C#++? (Score:5, Informative)
Re: (Score:3, Interesting)
Re: (Score:3, Insightful)
It's not that people think that's the only use for them; it's that that's the killer use.
It's a lot easier to persuade people to learn a new feature by saying "this will make your life easier" than by saying "this will let you write better code". Most people don't care how "tight" their code is, as long as it works. What they care about is how easy it is to wri
Truer words have never been spoken. (Score:5, Funny)
C++ is to C as Lung Cancer is to Lung
Re:Truer words have never been spoken. (Score:4, Informative)
Not sure how long ago I first heard that, and it's still as true today as it was back in '95. I think I first heard it from Greg Anderson, of Anderson Financial Systems (one of the old-time NeXT development shops.)
-jcr
Re:Truer words have never been spoken. (Score:4, Insightful)
True today as it was then; i.e. not true at all.
Re: (Score:3, Funny)
Nah, Stroustrup just decided to save time, so he's included the first buffer overflow in the language's name.
Objective C and C++ (Score:4, Interesting)
If anyone has used both Objective-C and current C++, can anyone tell me whether the new specification is a clear improvement on either if these?
I can. (Score:5, Funny)
Re:Objective C and C++ (Score:5, Interesting)
No, not really.
In fact C++ is barely managing to hold its own any more against C# and Java.
It's not that C++ isn't good, its just that its harder to do things in it then it is to do those same things in either C# or Java. Harder to do means more expensive, and businesses all over are having to tighten their purse strings.
I keep finding that for fast number crunching apps, C beats C++, and for less intensive work its usually easier to use Java or C#, or indeed python, then it is to use C++.
Also, its certainly true to say that in the UK C++ is not anywhere near as useful in terms of getting yourself a job as it used to be.
Re: (Score:3, Insightful)
The more I look at it, Java's Just in time compiler is just about as fast as C++.
The biggest difference tends to be how you program.
When you really learn to program OO, you tend to create many small objects that outlive the object that created them.
In C++, that would mean running thousands of mallocs a second, and having some other random (arbitrary) object delete them later.
That's not the way to code C++. Since you are constantly required to think of object lifetime, you usually have an object die with th
Re: (Score:3, Informative)
I still haven't seen anything matching it for real time stuff. Not that I wouldn't mind, at all.
But writing I don't think I've seen OpenGL code in another language that wasn't incredibly slow. Maybe that's just momentum, but regardless, it's still the state of things.
Re:Objective C and C++ (Score:4, Insightful)
Nothing else in your post either supports, or even directly addresses this assertion.
This is the same bullshit that's trotted out there every time this topic comes up, and it's no more true now than it ever was, which is not at all. If you do a little looking around, you'll find very elegant libraries that support every single feature you'll see in ANY other imperative language, and MANY declarative language features to boot. If you're against code reuse and third party libraries on some sort of general principle, then you're kinda missing the whole point of C++.
I'll be blunt, maybe an ass, maybe a troll, but having used all three of those languages extensively, I can say with almost absolute certainty that the only reason you should be having so much more trouble doing things in C++ (ESPECIALLY as compared to those two languages) is that you're either a very poor C++ programmer or have a pathological aversion to third party libraries.
Another thing that's been very much in the vogue to say lately, but I just haven't seen any meaningful evidence for. I think Bjarne covered this topic fairly even-handedly in TFA, and if he's to be believed then C++ usage is not suffering like popular belief seems to indicate. The crux of it being that web scripting was never a strong domain of C++ in the first place, and in actual applications programming C++ is still the leader of the pack.
Re:Objective C and C++ (Score:5, Insightful)
Generally speaking, I agree with your post. However...
That's a really, really awful way to think about C.
C has a completely different set of best practices and design principals; anyone who puts "C/C++" on a resume I'm reviewing loses points as opposed to listing them separately.
Re: (Score:3, Informative)
Not to mention that C is not a subset of C++. The differences are minor and mostly subtle but they are there and they matter. For example, this trivial bit of very typical C code will not compile in a conforming C++ compiler:
char *x = malloc(10);
I'd suggest asking your "C/C++" interviewees to produce some code that's legal C but not legal C++. It will at the very least be amusing to watch them squirm.
Re:Objective C and C++ (Score:5, Informative)
Objective-C is essentially unrelated to C++ in every way. C++0x does not change this fact at all. Comparing the two makes just slightly more sense than comparing C++ and Prolog.
Re:Objective C and C++ (Score:4, Funny)
If you're writing C++, the spec is an improvement. If you're writing Objective-C, you probably don't care because you've already got a great language.
Also, you'll gnash your teeth because god knows how long it will take for apple to provide a compiler toolchain ( gcc? llvm? clang? ) which supports the new features.
On of the features: (Score:5, Funny)
"control of alignment"
I'd like chaotic good please
Re:On of the features: (Score:5, Funny)
I hate to be the one to break the news, but C++ isn't the only thing that's been revised recently...
LOL C++0x0Rz (Score:5, Funny)
Re:LOL C++0x0Rz (Score:5, Funny)
Re: (Score:3, Funny)
"C lets you shoot yourself in the foot. C++ lets you reuse the bullet."
Re: (Score:3, Insightful)
Early interview still more interesting (Score:4, Funny)
Just want to remind everybody (Score:5, Informative) [yosefk.com] - this site says it all.
And it's also being argumentative and verbose at that, unlike your routine 'C++ sucks' rant.
Re: (Score:3, Interesting)
I looked at that, and at first it seemed, well, this is fair. A lot of these things are drawbacks, and it's pretty well laid out. Then I read into it a little further... and I really have to wonder. A lot of it is just WILDLY exaggerated. I mean, the author clearly tried to blow some minor problems up to ridiculous proportions. Some of the stuff in there is just absurd. Gems like this:
Re: (Score:3, Informative)
Your example uses a const std::vector<T> . He's talking about const std::vector<T*> , i.e. a const vector holding pointers. In such a case, you most certainly can modify the objects those pointers reference.
Fingers Crossed for Native Implementations (Score:3, Informative)
I really, really, really hope a lot of these things are implemented as compiler- or runtime-level features. I understand the purity aspect of implementing features as templates, but it just bloats my code and slows my compile times. A lot of the compile time for my apps is spent regenerating the same template crap over and over, then waiting on the linker to weed out what's duplicated. It takes forever.
Time for the C++ haters to post... (Score:4, Insightful)
We will see the usual litany of C++ hating here in this thread. The hating will be generally based around misconceptions or problems that are 5 years old.
So to get them out of the way:
If you're leaking memory or spending time managing memory in C++, then you're using C++ wrong. Get a book written in the last 5 years.
If you're worried about compiler compatibility (with the exception of export which isn't much use anyway), get a compiler written in the last 5 years.
If you think that C does some subset of your task better, then write it in the common subset of C and C++ and quit whining. Or, write it in C and link it against your C++ code and quit whining.
If you think that templates simply provide code bloat, then get a compiler newer than 5 years old.
If you think C++ is slower than C, then get a good optimizing compiler (you know one written in the last 5 years) and do a benchmark. You will generally find that templates make C++ faster.
If you think "modern" languages are more expressive, then give "modern" C++ a try (insert comment about recent compilers here).
Sure there are valid complaints about C++, but the majority of them I hear on slashdot are complete bull. The majority of the remaining complaints will be fixed by C++0x.
One remaining problem is the lack of a vast array of standard, business oriented libraries. I don't write business oriented code, and I find the C++ STL one of the best libraries out there since it provides really good support for writing efficient algorithms.
Another problem is the difficulty in parsing C++. Sadly that's never going away.
But if you're going to complain about C++ compared to recent languages here, make sure that you're talking about recent C++ too, and try to make sure the complaints are accurate.
Re:Time for the C++ haters to post... (Score:4, Funny)
To be fair, the majority of complaints you hear about most programming languages on Slashdot are complete bull. People complain about the ones they don't like or don't know well enough and praise the ones they do like.
Once in a while you'll get someone who admits their pet language has faults and warts who explains why they use it anyway. On rare occasions, you might even hear someone say that a language they dislike has their language beat in some way or another. None of these are the rule, though.
Personally, I think of the C family of languages as an actual family... The patriarch C is somewhat portable macro assembly all grown up with some new tricks his dad never knew. C++ is C's little brother on steroids, complete with the unsightly rippling veins and man boobs. Java is C++ castrated and off the juice. Perl is the awkward bastard child of C and sed with a great skill for vocabulary but a wild of ADHD. C# is Java's soap-opera style evil twin. Objective C is C++'s hot female tree-hugging cousin from northern California who can't quite understand why the family always bickers and can't just get along. D kind of married into the family (probably to Objective C) and brought in a bunch of non-C things back to a style that suits C pretty well, even if he is a young punk. Cmm is the weird survivalist uncle none of C's kids, nieces, and nephews really want to spend time with at the holidays.
It's a pretty dysfunctional family, but on some level they all belong together. They're not as sophisticated as the Lisp family down the street. They don't coordinate as well as the Concurrents. The Pascal and Modula clan talks a lot more and is stricter with their rules. The C family just keeps getting useful work done, though, and that's why people keep coming back to them.
My primary language is Perl, but then again I'm an awkward guy with a gift for vocabulary and a wild case of ADHD. At least I know who my father is.
C++ has one major problem (Score:5, Insightful)
auto rocks (Score:5, Interesting)
The new "auto" declarations really fix one of the biggest gripes with C++. Everybody is dead tired of doing
std::map::iterator it = m.begin()
Now you can just do:
auto ip = m.begin()
It takes much of the pain away from static typing...
Re: (Score:3, Insightful)
std::map::iterator it = m.begin()
That'd be "map<signed short int, unsigned long int>::iterator it = m.begin()". And you can write "using namespace std;" instead of "std::", saving a net minus 15 characters
;)
C++ is no longer a modern language (Score:3, Interesting)
C++ was once thought to be a language that was powerful enough that it could be used to express most features that other languages had. With things like operator overloading, multiple inheritance, and templates, you could pretty much make a class behave however you want. But years later, we have seen that C++ failed at that mission. There are simple and common OO constructs that C++ is unable to represent. Rather than focusing on improving the template functionality, I want the OO syntax fixed.
Let me cite some examples:
1) It is impossible to make a string class that behaves "normally"
Plenty of people have tried. QT, Boost, STL, Gnome, WxWidgets, all have their own string classes. Years ago, when VB developers touted how easy it was to use strings compared to C++, I told them it was merely because nobody had made a good string class. After 10 years of trying to write one, and using dozens of other ones people created, I realized that C++ is simply too weak and too loosely typed to do this.
Suppose I make a string class, kinda like the STL string:
string foo;
1) foo = "whatever";
2) foo = foo + "bar";
3) foo = 7;
4) foo = foo + 7;
5) foo += 7;
Take a look at these. The first one is no problem. That can call an assignment operator to copy the char * contents to the string. The second one can also be done with a + operator. The third one can also be done via assignment. But what if you forget that? Well, the compiler will see that as foo = foo(7) which will call the constructor that allocates 7 characters, and then assign that. So instead of the string "7" you get a blank string. The next example is a problem too. If the string class can be converted to a const char *, as is common, then does this mean to use the + operator on string and an integer? Or did it mean to convert foo to a const char *, then move 7 characters ahead, then assign it? That can result in a crash. This is because pointer arithmetic is intrinsic in C++, but it is inherently type unsafe.
Then how about a function that returns a string? A simple case in most languages, but in C++ it results in redundant copies across the stack. So people revert to funny things like auto_ptr and other wrappers, or complex mechanisms for doing shallow copies to prevent that. Other languages just avoid the problem entirely by not allocating things on the callee's stack. It's just an intrinsic problem in the old everything-goes-on-the-stack-by-default mentality of C++. It just doesn't always work.
Properties are another one. This is something that various libraries try to do, and is free in most new OO languages. But just cant be done in C++
// C#
class Foo
{
private int _x;
public int x
{
get { return _x; }
set { _x = value; }
}
}
So in the above class, I want to access _x via a property get/set. C# has a built-in construct for this. In C#, I could do:
MyFoo.x = 7;
MyFoo.x++;
MyFoo.x = MyFoo.x + 3;
MyFoo.x/= 7;
etc. The compiler knows how to get/set x, and it can even be inlined! This allows me to do things like log when x changes, or see what accesses the variable. Now, let's try that in C++.
class Foo
{
private:
int _x;
public:
// Get X // Set X // Another way to get/set X
int x();
void x(int);
int &x2();
};
MyFoo.x();
// Gets x, no problem // Weird syntax, but that is fine // Does not modify the value of x, hmmm... //
MyFoo.x(7);
MyFoo.x()++;
MyFoo.x2()++;// Modifies x, but only lets you track the get, not the set.
MyFoo.x()/=7;// Same exact issue
MyFoo.x(MyFoo.x()/7);
Re: (Score:3, Interesting)
Properties are another one. This is something that various libraries try to do, and is free in most new OO languages. But just cant be done in C++
I never really understood this effort. What is so good about properties? Why is writing () after getter function name so hard? And for setters, setter chain is much less verbose anyway, like
mywidget.NoWantFocus().SetReadOnly();
instead of
mywidget.nowantfocus = true;
mywidget.readonly = true;
Why should any language look like Visual Basic?
Re: (Score:3, Informative)
Re: (Score:3, Informative)
The problem isn't that it c
What tool is better than C++? (Score:3, Insightful)
I also have an extensive experience with C++, and I tend to agree with a lot of the criticism that it gets.
But the problem is that no alternative exists for the type of problems where C++ is used extensively. I guess the most important area is games.
The world really NEEDS a language (the last low-level language) with the low-level performance of C++/C and with a full, modern library, and modern language features (threading, modern module system (not based on #includes and a crude preprocessor...), optional strong typing system a la Ada with optional runtime-checking etc etc etc.
Basically, a really nice, compiled, well-performing, modern low-level language could easily exist. But it doesn't. So we'll have to settle for C++ until someone makes something better.
Re: (Score:3, Interesting)
I guess D is dead? Could have been a lot of hype but it sounded like the language you were looking for.
Wait a minute... (Score:3, Informative)
The C syntax is horrendous, the conversion rules chaotic
Bjarne Stroustrup, creator of C++, is saying that C has a horrendous syntax and chaotic conversion rules...
Hahahahahahahahaha.
Re:Interesting suffix (Score:4, Informative)
Yes. It's already been done once, aka C99. This isn't the thing that will replace C++, it's the next revision of the language, with multithreading support etc. Once C++ has worked out the hard stuff, C will have it's own next revision based on that.
Once everything's finished, it should be finalized as C++09. It may carry on another year, in which case you might call it "C++0xa"
;)
Re:It hurts you to learn C++ is still being used. (Score:5, Insightful)
Been there, done that.
Most of the time, the potentially reduced running time of the C++ implementation never comes close to the months saved in development.
And when it does, it's trivial to go in and write the speed-sensitive portions of the program in a faster language.
I just don't get it.... (Score:5, Insightful)
...what do people find so difficult about C++? Use the standard libraries, exception handling, and make sure your news all have deletes, and it's no more difficult than any scripting language. I actually prefer it over scripting languages, which have their place, but feel all sloppy and unspecific. It's like the difference between building a house out of 2x4s and building one out of sticks you found laying on the ground.
Re:I just don't get it.... (Score:5, Interesting)
Well, here's what I personally dislike about C++. You don't have to agree with them, but this is how I feel and I think it's how many other people do as well. Certainly when talking to people who prefer other languages over C++, they have expressed similar sentiments.
The really big issues for me are the flexibility and the lack of libraries. The rest is less important. But with C++ it's like building a house out of 2x4s that you're not allowed to cut to length, whereas with moer modern languages it's more like building a house out of prefabricated rooms, with a ready supply of 2x4s and tools to shape them as you need if the prefabbed rooms don't fit your needs.
Please note that this is just my opinion, and you asked for it. Feel free to disagree, but please don't flame.
Some counterpoints. (Score:3, Insightful)
1. Boost.
2. Nonsense. Boost has facilities for this ("any", iirc) and also for something called "sum" types which can achieve what you want in a better way ("variant", iirc).
3. shared_ptr, weak_ptr.
4. Yup. Going to be fixed by C++0x.
5. C++ can be written to be a lot more portable than your Ruby or Python.
6. A matter of taste.
Re:Some counterpoints. (Score:5, Interesting)
Counter-counterpoints:
d = {"name":"Bob", "age":42}
print "Name is %s and age is %d" % (d["name"], d["age"])
Keep in mind that this is a complete python program, no further code is required.
Re: (Score:3, Informative)
Now you're just being unfair.
1. I found it pretty easy. Most Boost libraries are header-only so you only need to put the relevant header files in your project, adjust your header search path, and you're done.
2. Your example hasn't got much to do with C++, and everything to do with static vs dynamic typed languages. The C++ version will be about the same size as the Java and C# versions.
3. Uhm sorry, "real garbage collector" and "Python"? You do know that Python uses reference counting, right? Just like shar
Re:Some counterpoints. (Score:4, Insightful)
Again, I don't think I'm being unfair, I'm just saying why I use what I use. Python provides more libraries for the stuff I use than C++ does. "Batteries included" makes my life easier. Maybe this isn't fair to C++. So what if it's not? Should I make my life more difficult by using C++ out of a sense of fairness?
As for GC goes, no, it's not "just another memory management aid". Non-GC versus GC is the difference between having to think about memory management and not having to. Automatic refcounting still forces you to manually find and break reference cycles, and garbage collection does not.
Re: (Score:3, Informative)
Well, something in the range of 99% of the desktop applications available on Mac OS X are written in a duck-typed true OO language.
I hold that the main reason that C++ is used so much for large desktop applications on Other Platforms is inertia, pure and simple. Programmers hate change. I realize that this is a purely a statement of opinion and I have no way to back it up.
Re: (Score:3, Informative)
It's the difference between being able to type "import", and having to search, download, compile, and pray. As for few modules being part of the language, every example I listed is built in to Python.
Re:Some counterpoints. (Score:4, Informative)
Yes, if C++ included the same libraries that Python does, this objection would go away. (Why wouldn't it?) The other objections would remain.
And no, GC does stop you from having to think about memory management. So-called "soft leaks" aren't a memory management problem, they're just a regular old code bug. GC doesn't save you from all bugs, or even from a particularly large number of them. It mainly just saves you from programming overhead.
GC also doesn't save you from having to manage external resources as that SafeHandle class does.
RAII is definitely not the design pattern I want. Believe me, I know what RAII is, and I know what I want, and the two do not intersect in any way.
I know it's hard to believe, but there are people out there who legitimately do not like C++. Not because we're stupid, or clueless, or because we've been misled, but simply because we have different constraints on our programming or even just different opinions.
Re:Some counterpoints. (Score:5, Insightful)
Boost has in many eyes really transcended from "just an external library" to an integral part of the C++ platform. It compiles on every major platform, and it is open source.
Boost is moving C++ forward at a rate 10x that of the standards committee. I am not sure why you felt integrating it with your project was difficult- it is header only for the most part and does not require you to use any specific pieces. Shared_ptr's, which are the most useful library of all, do tend to be viral in the sense that you have to use them everywhere, but this is a GOOD thing.
If you are doing C++ without Boost these days, you are really missing the boat.
Re:Some counterpoints. (Score:5, Insightful)
It is the discussion. Judging c++ with boost excluded is like judging perl with CPAN excluded. Who cares whether it's "part of the language" or not? Everyone who uses the language seriously uses them, and they're critical to understanding how the language is used effectively.
Re:Some counterpoints. (Score:5, Interesting)
It doesn't solve anything that *couldn't* be solved before, but that's not the point, as anything can be solved given enough time and effort.
But out of the box, without even any compilation needed(!) you can get smart pointer implementations, timers, asynchronous I/O, a multithreading toolbox, conversion libraries, containers, memory pools, and tons more (some would say so much more that its bloated) with the added peace of mind knowing that tons of people out there are using them as well and they are thoroughly debugged. Its worth it for the shared_ptr's alone- those alone dramatically reduce the biggest source of C++ bugs.
In my previous company, I worked on a system that was about 10 years old- started before the STL came into existence, and long before it was well supported by compilers, and thus the team had spent a lot of time building STL-like functionality with dynamic strings, iterator like functionality, vector/list work-alikes, etc. This meant that now once the STL came around, a programmer familiar with "standard" C++ had to learn how to re-do mundane things like string and container manipulation. Similarly, that team had created smart pointer implementations, logger classes, multithreaded and socket libraries, etc. Boost not only provides all of this functionality, but you get it working right out of the box, and since Boost is well known, you don't have to wait for a programmer to get up to speed for a month or two while he becomes familiar with your code.
There are some more exotic features that you don't have to use, but I recently used multi_index to implement what is more or less an in-memory database cache in about 100 lines of code. This replaced a lot of code that read records and then threw them into hash maps or vectors using the OrderId as a key, then the CustomerId as a key, etc... so we had fast lookups to our most commonly used objects.
What are its advantages over ACE? ACE is a great networking and concurrency library, which not all applications necessarily need, and ACE's strong point is multi-platform networking and concurrency, which while I wouldn't call a small niche anymore, can't be used across all applications. At least some of Boost's libraries, most notably shared_ptr, can be used in any C++ program. In fact, until Boost::asio was released relatively recently, I would say ACE and Boost were entirely complementary. Also, boost is more or less a testing ground for the C++ standards committee, so it is more or less "blessed" and can be seen as a Beta for future versions of the standard.
Re:Some counterpoints. (Score:5, Insightful)
First off, if you have a problem with using external libraries, then you just won't get anywhere with a C/C++. They are VERY general purpose, and intentionally so, and the whole idea is that implementation specific things are supposed to be provided in libraries, rather than the core language. That said:
1. Boost is actually very easy to integrate for most of its features. A few (small handful) of its components require compilation, but the vast majority of them are template-based and header only. Meaning just include a header file and there you go, you're using boost. No extra compilation/installation required.
2. This kind of thing is GREAT for doing small scripts, but HORRIBLE for doing large complex applications where type safety can be VERY important for avoiding bugs. If all you ever do are small, quick, limited scripts, then you're absolutely right that you should avoid C++, that's certainly not what it was meant for, and not so much the domain of a strongly typed language. For things like the software that runs large financial institutions and whatnot, there's a reason code like that should be avoided at all costs.
3. I have trouble imagining a situation where a real garbage collector would ever be superior to an RAII model with shared smart pointers for stuff allocated on the heap, outside of plugging up a leaking legacy app. Maybe for very simple programs, but once you get non-trivial destructors (for example, with objects that lock system resources), then you start having to do manual memory management in your GC environment anyway, and end up with a horribly ugly conglomeration of "mixed metaphors" as it were. Smart pointers really give you the best of both worlds: deterministic destruction, without having to worry about manually releasing anything. It's just a matter of getting used to declaring a smart pointer wherever you would have a "type *name" instead. So yes, I'd argue they ARE a substitute for garbage collection in almost any situation.
4. Sorry to be blunt, but you should probably RTFA on this one. The problem is solved through "concepts," which is the part of the new specification which deals with this specifically. It's essentially a C++ implementation of the "design by contract" metaphor.
5. In this case "can be" equates to "do whatever you like and it'll be portable on all major general purpose computers, and who uses Ruby or Python on embedded platforms anyway?" If you are able to compile with GCC, which is the case for pretty much every computer/OS combination in existence, then you can count on it being pretty damn portable. If you are programming for something like an ATM or a set-top box, then you probably aren't going to be using a high level scripting language anyway.
6. Yeah, it can get ugly. Thankfully this will be largely fixed with the "auto" keyword in C++0x.
Re: (Score:3, Informative)
Easy:
Re: (Score:3, Insightful)
d = {"name":"Bob", "age":42}
print "Name is %s and age is %d" % (d["name"], d["age"])
Keep in mind that this is a complete python program, no further code is required.
So you don't count the Python runtime as further code?
These types of examples are meaningless. Any programming language can implement the same functionality, they just use different syntactic sugar to do it. So great, Python allows you to define a dictionary in a single line of text. Doesn't mean you can't define a dictionary to do the same thing in C++, it is just the form looks different.
But notice that in your language, you had to know that d["age"] is an integer and d["name"] is a string when you buil
Re: (Score:3, Interesting)
Twisted? I wasn't talking about a 68000 or a Palm. I was talking about an embedded microcontroller with a grand total of 32kB of RAM. About half of that is left to hold both program and data once the kernel gets done taking what it wants. Can you fit Python into 16kB of RAM for both program and data, and still have enough space left over to do anything useful? I'll be very interested if your answer is "yes", but I'm doubtful.
Don't get me wrong, I'm a huge advocate for higher level languages. But there are c
Re: (Score:3, Insightful)
For 32KB systems, I would recommend either absolute assembler, or program conversion - higher order to lower order (subset Scheme to assembler, and possibly TinyScheme). Even C is excessive, but possible. C++? Unless you have absolute control on template production, I would doubt it.
Simply because using the STL and making a SINGLE type change can result in inclusion of thousands of bytes of code (as the templates instantiate). Example: modify a short vector to a long int vector on the platform. The machine
Re: (Score:3, Insightful)
Flexibility. In C++ it is essentially impossible to make, say, a dictionary where each key can refer to an object of a completely different type. This is what you refer to as "sloppy", but I actually find this flexibility to be essential in designing good software. The fact that C++ does not allow it forces me to either twist my program's design in unnatural ways to fit the language, or do a lot of extra work to twist C++ to fit my program's design.
If you're not offended by the idea of using the Boost libraries, the boost::any class will let you be sloppy like that.
Manual memory management. In any complex program, balancing your news with deletes is not as simple as you make it out to be. Object ownership is a tough problem. Lots of C++ code solves this problem by making a lot of defensive copies, which in turn hurts performance greatly.
The boost::shared_ptr class has changed the way I write C++ code. It's a header-only class, so it's possible to only include it, and nothing else from Boost, in your project.
Readability and writability. With all the type information being declared all over the place, big template declarations, and the like, I find that C++ takes considerably more effort to both read and write.
I have found that wise use of typedefs can hugely improve readability and writability. On the other side of the coin, some people go overboard with typedefs, essentially making worse the problem they originally intended
Re: (Score:3, Informative)
no, I think he meant a map where the value part can be any type, not just the one stated in the definition.
eg.
map.insert(1, "hello");
map.insert(2, 69);
map.insert(3, myobj);
etc. Boost::any is what he's after in that case so its a pretty moot point.
Re:I just don't get it.... (Score:4, Funny)
Error 2317 - Invalid analogy - no wheels. Bailing...
Re: (Score:3, Insightful)
There is nothing preventing anybody from bad habits in coding and putting nails into own foot. Whether you use hammer or nailgun it makes your foot ache all the same.
Re: (Score:3, Informative)
And when it does, it's trivial to go in and write the speed-sensitive portions of the program in a faster language.
Agreed. Premature optimization is the root of all evil. Write the control flow in a high-level, easy-to-debug language, and later optimize the pieces running unacceptably slow by rewriting them in C. No object-oriented language with legacy holdovers, static typing, and gross syntax needed.
Despite knowing it is a fallacy, I will instruct by appealing to my experience: 27 years coding, 10 of that with a salary, and 5 years before that as an entrepreneur. I have forgotten more C++ than most people know, ha
Re:It hurts you to learn C++ is still being used. (Score.
Re: (Score.
Citation needed. What is post-2000's C++? Please enlighten me. All of my professional C++ experience occurred between 1999 and 2006, conforming to the 1998 ISO/IEC spec sitting on my desk, with various modifications made for broken compilers (e.g., VC++6, the lack of support for the export keyword in any C++ compiler I've used, etc.). If there's a later "version" of C++ that is supported by gcc, I have not heard of it.
I did some C++ programming in high school and college, but didn't really dig in until
Re: (Score:3, Informative)
Read: [amazon.co.uk]
It's a good introduction to modern C++. While the book itself is not really helpful, it gives you a nice overview of "modern" development techniques.
Re:It hurts you to learn C++ is still being used. (Score:5, Interesting)
I am not going to go read a book simply to settle an argument: you need to summarize here.
In particular, explain to me why his techniques are not generally applicable to other languages (or to Python or Ruby in particular) or why using those techniques or similar ones and interfacing to C when necessary actually provide a less efficient development environment.
I know C++ can be made "acceptable" as a high-level language through sufficient effort; I spent 7 years doing such a thing. I want to know why that's a better solution than using tools that are---out-of-the-box and without reference to a magic cookbook---ready to do the things that require months of development or dozens of third-party libraries to achieve in C++.
Re: (Score:3, Informative)
To summarize it, C++ now moves toward design which allows to catch more and more errors during compilation. But at the same time C++ provides tools which allow to write generic code.
Re: (Score:3, Interesting)
Yes, this sounds logical. C++ has only recently become interesting. C++0x back in, say, 1999, would have totally killed off Java.
Re:It hurts you to learn C++ is still being used. (Score:5, Insightful)
No, the "premature optimization" thing applies to all areas. Especially areas where it's never fast enough.
Why? It's simple: resource management.
You have X amount of resources to put into your product. X is always finite. It's kind of tough to measure X, but you can think of it as lines of code, man-years, or even just dollars. The amount of resources you have varies a lot depending on your budget, how much time you have, and the quality of the programmers you have. But the important thing is that X is always limited.
Now you have two approaches:
Paradoxically, I hold that #2 will produce a faster program. This is because the X you spend on making the program faster in #2 will be more effective, because you've already laid the groundwork for it. It's always difficult and time consuming to optimize code that doesn't even run yet. It's much more efficient to optimize code that already works. So the result, even though you spend less X on speed, is a faster program.
Think of it as transporting a lot of material into the wilderness somewhere. If you first spend some of your resources on building a road, you'll get the job done for less time and money than if you just start hauling stuff into the woods immediately.
Re:It hurts you to learn C++ is still being used. (Score:4, Insightful)
I've found that the biggest advantage for C++ is the portability. I have written an application backend for PC's (back in the days of DOS) and since then ported it through various versions of windows, Linux (for web use), Palms, and Pocket PC's.
Using C++ allowed me to very easily make the different processor needs, compatible, by writing little compatibility layers, which would swap bigend values, unpack data structures from disk into memory (so is on even boundary). and so on.
Yes the fast speed was why I originally went with the C/C++ route, but the big benefit has been the portability.
Re:It hurts you to learn C++ is still being used. (Score:5, Insightful)
You do know that you don't have to screw around with any of that in a managed language, right? "Very easily make the different processor needs compatible" my ass--Java/C# do it on their own.
Re:It hurts you to learn C++ is still being used. (Score:5, Insightful)
...and roll on the C++-hatred! Second C++ article in a short time, and again lots of venom and anger. "Months saved in development"? Really? What are you doing, implementing your own OS before you start application development? Here's a newsflash: C++ also has support libraries, just like Java, Perl, Python and Ruby. They may not be part of the language specification (and I still think that's a weird idea to begin with, but I'm old-fashioned that way), but that doesn't mean they don't exist.
Anything you could want for in a modern language is there. And nobody is holding a gun to your head and making you write those scary templates if you don't want to.
I'm just positively amazed that Slashdot, in theory home of programmer geeks anywhere, should have such a violent dislike of C++. Not that there is nothing to criticize about it, but it is still an amazingly powerful, versatile tool that programmers anywhere would do well to learn.
Re:It hurts you to learn C++ is still being used. (Score:5, Interesting)
> I'm just positively amazed that Slashdot, in theory home of programmer geeks anywhere, should have such a violent dislike of C++.
Because C++ is not a pure language. It is a multi-paradigm language (imperative, OO and functional) with both a high and low-level language features and people seem to hate the aspect they which they don't prefer.
The close-to-the-metal types hate the high-level aspects and rather use C. Disregarding the fact, that changing the code from C to C++ is purely syntactical and runs without any detriment in performance. Exactly the prime idea behind C++.
The high-level people dislike C++ exactly for this approach. They don't like that the basics are so clearly visible, and are even the default. You have to hop through some loops, before you get to a higher abstraction layer. E.g. you have to use external libraries and/or special classes for memory management.
Personally, I like C++ for exactly that reason. I can start on a fairly abstract layer with pure virtual interfaces, smart pointer, signal slots and there is not a single (raw) pointer or a manual deallocation to see (or other manual resource deallocation).
Granted, it is more verbose than in a pure high level language, but that is what the machine has to do.
And if there is a performance bottleneck, I can seamless go down in the abstraction level from simple inline functions, over imperative functions with pointer arithmetic, down to inline assembler and can even guarantee a certain timing, if necessary.
Re:It hurts you to learn C++ is still being used. (Score:4, Insightful)
There are vanishingly few programmer geeks left on slashdot. Most of the "programmers" here, these days, are folks who've written a few scripts or set up a movable type install.
There are a few real programmers left here, but they're lost in the noise. You know, the roaring noise made by the python and ruby folks.
This post brought to you by a C++ programmer who happens to love Python and Ruby ( and javascript! it's an amazing language ), but uses the different languages where appropriate.
Re: (Score:3, Interesting)
They may not be part of the language specification (and I still think that's a weird idea to begin with, but I'm old-fashioned that way),
I work a lot with C++/Qt, but it's damn near that I want to say I program in Qt instead of C++. What's the problem with that? Well, I'm essentially lost if I have to work on a STL/WinAPI/MFC/wxWorks/boost/whatever project. Not in that I don't grok C++ which I do, but that I don't know any of the objects or functions or whatnot being in use. I do realize that there are differences between the libraries but certain basic functions should just be common, there's no reason why you'd need more than one string cl
Ha! Yeah right. (Score:3, Funny)
Those languages are way too high level. What you make up in development time will nowhere near compensate you for the greater processing time. I mean, CPU costs are through the roof these days!
But I have to say - even C++ is too high level. I hand code assembler with vi. That's what real number crunchers do.
Re:And Then COBOL 2009 (Score:4, Insightful)
Re: (Score:3, Insightful)
Re:And Then COBOL 2009 (Score:5, Insightful)
I'll consider Java and C# as C++ replacements once they get:
These points are serious, especially the first, without real templates, generic programming/metaprogramming at compile-time is not possible. These two are one of C++'s biggest strenghts, though.
To be fair, C# 3.0 is somewhat nice, especially its functional core. Java is a totally uninteresting language with very small expressiveness. Of course, if the job requires it, there is no discussion, but in my spare time, I prefer C++.
Re: (Score:3, Interesting)
These are all very good points, particularly regarding RAII. I'm sure you know this already, but other languages such as Python provide deterministic resource management as well (in Python, it's the "with" statement). Java, along with C, seems to be one of the few languages that have absolutely no faculties for the RAII pattern.
Re: (Score:3, Interesting)
"Java, along with C, seems to be one of the few languages that have absolutely no faculties for the RAII pattern."
Really?
What about:
COBOL
FORTRAN
VB
Prolog
Lisp
ML
In fact any non-OO languages , given that RAII is an OO concept.
templates... (Score:3, Insightful)
I used to think like that, but then all the things you talk about are just syntactic sugar. There is nothing you can do with proper generic that you can't do in Java or C#. Yes, C++ is way more expressive than almost any other language, but that is also its peril.
And when was the last time you used meta programming to solve a concrete problem that could not be elegantly solved otherwise.
Most people learn how to calculate a factorial using meta programming techniques and stop right there. It's more of a curi
Re: (Score:3, Interesting)
> I have been involved in developing code for simulating cosmic-ray acceleration in expanding supernova remnants, this in Python.
Well, Python is a different game than Java or C#, which both have a much better JIT-compiler.
I mainly program in C++ (real-time data processing), but I feel hard-pressed to believe, that Java has to be severely slower than C++ in numeric computations. The Java implementations of FFT [googlepages.com] and LinPack [shudo.net] suggest, that comparable performance should be possible. The SciMark 2.0 should also
Re:Why not just call it C++#? (Score:4, Insightful)
Trust your uncle Bjarne. If you don't use it, you don't pay for it. You need not worry that the language is turning into C# or Python. It's still just as efficient for bare-metal programming as C ever was (and more so in some cases, with template specialization at compile time).
As for 'automatic memory management', that was one of C's big features. Remember the 'auto' keyword?
Re:Why not just call it C++#? (Score:5, Insightful)
Oh please. Pascal does everything C++ can now [freepascal.org].
Re: (Score:3, Funny)
Not to worry. As a result of the nuclear launches following the panic resulting from the 2038 Unix date rollover, the remaining cockroach hordes will not evolve sentience until at least 2105, thus avoiding the 2099 crisis completely. So it's all good.
Re: (Score:3, Insightful)
I want to like C++, heck, it was the first language I learned. But after so many hours of memory leaks and pointer-induced errors...
perhaps you didn't learn it very well. Check out RAII [hackcraft.net] for one way round your problem, learn about references and destructors for another, and learn about auto_ptr/shared_ptr if you still have difficulties.
If you absolutely must have a GC, put one in [hp.com]. Mono uses this one, so I assume they think its quite good. Stroustrup says that GC has a place in memory management, but it shou
Re:Garbage Collection? No? BAH! (Score:4, Informative)
Re:To all the C++ haters (Score:4, Funny)
Please elaborate; I'd like to hate C++ more effectively. | http://tech.slashdot.org/story/08/08/21/1521236/interview-update-with-bjarne-stroustrup-on-c0x | CC-MAIN-2014-15 | en | refinedweb |
Hi, I am trying to make a simple program which is meant to resemble a hospital patient database.
My aim is that when the user types in a patients name, I want it to type a couple of messages using methods which I have done successfully, for example "searching database". I want the program to then search an array for the patients name, if found, print the patients details/medical history onto the screen.
Here is a sample of what I have got so far, I have been watching tutorials off youtube for guidance:
Code :
public class HospitalOne { private String patient; public void setPatient(String name) { patient = name; } public String getPatient() { return patient; } public void details() { System.out.printf("Patient: %s", getPatient()); } public void searching() { System.out.println(""); System.out.println("Searching Database..."); } public String[][] patName[100][10]; patName[0][0] = "Name: Stephen Myhill"; patName[0][1] = "Location: Chesterfield"; patName[0][2] = "D.O.B: 31/2/80"; patName[0][3] = "Medical History:"; }
Code :
import java.util.Scanner; class MainProgram { public static void main(String[] args) { Scanner input = new Scanner(System.in); HospitalOne col = new HospitalOne(); System.out.println("Enter the name of the patient: "); String tempP = input.nextLine(); col.setPatient(tempP); col.details(); col.searching(); if (col.patName[][].equalsIgnoreCase(tempP)) { } } }
I am getting all kinds of errors but cannot identify and fix them. I don't even know if I am doing this correctly.
My questions are:-
- Where should I be creating my array?
- Should I have a multi-dim array or should I use arrayList?
Thank you for your time.
Regards,
SS.
P.S - bit off topic, but what is wrong with java-forums.org (It is not loading for me anymore. I had a PM from some dude, replied and since then cannot get back on there). | http://www.javaprogrammingforums.com/%20object-oriented-programming/10684-where-do-i-create-my-array-printingthethread.html | CC-MAIN-2014-15 | en | refinedweb |
#include <perfmon/pfmlib.h> int pfm_dispatch_events(pfmlib_input_param_t *p, void *mod_in, pfmlib_output_param_t *q,void *mod_out);); ... | http://www.makelinux.net/man/3/P/pfm_dispatch_events | CC-MAIN-2014-15 | en | refinedweb |
This section is normative.
The XML Events Module defines a linkage between XHTML and the XML Document Object Model [DOM]. XML Events are defined in [XMLEVENTS], and all XML Event elements and attributes are in their own namespace.
This module includes the ev:listener as defined in [XMLEVENTS].
This module also defines the Events Attribute Collection via the global attributes from [XMLEVENTS]. | http://www.w3.org/TR/2006/WD-xhtml2-20060726/mod-xml-events.html | CC-MAIN-2018-05 | en | refinedweb |
.dotbetwixt;19 20 import java.util.ArrayList ;21 import java.util.List ;22 23 /**24 * @author Brian Pugh25 */26 public class Father {27 28 private List kids;29 private String spouse;30 31 public String getSpouse() {32 return spouse;33 }34 35 public void setSpouse(String spouse) {36 this.spouse = spouse;37 }38 39 public List getKids() {40 return kids;41 }42 43 public void addKid(String kid) {44 if (this.kids == null) {45 this.kids = new ArrayList ();46 }47 this.kids.add(kid);48 }49 50 }51
Java API By Example, From Geeks To Geeks. | Our Blog | Conditions of Use | About Us_ | | http://kickjava.com/src/org/apache/commons/betwixt/dotbetwixt/Father.java.htm | CC-MAIN-2018-05 | en | refinedweb |
#include <avfilter.h>
Definition at line 244 of file avfilter.h..
Slice drawing callback.
This is where a filter receives video data and should do its processing.
Input video pads only.
Callback called after the slices of a frame are completely sent.
If NULL, the filter layer will default to releasing the reference stored in the link structure during start_frame().
Input video pads only.
Callback function to get a buffer.
If NULL, the filter system will handle buffer requests.
Input video pads only.
Minimum required permissions on incoming buffers.
Any buffer with insufficient permissions will be automatically copied by the filter system to a new buffer which provides the needed access permissions.
Input pads only.
Definition at line 266 of file avfilter.h.
Referenced by avfilter_start_frame().
Pad name.
The name is unique among inputs and among outputs, but an input may have the same name as an output. This may be NULL if this pad has no need to ever be referenced by name.
Definition at line 251 of file avfilter.h.
Referenced by avfilter_graph_check_validity(), and pad_count().
Frame poll callback.
This returns the number of immediately available frames. It should return a positive value if the next request_frame() is guaranteed to return one frame (with no delay).
Defaults to just calling the source poll_frame() method.
Output video pads only.
Permissions which are not accepted on incoming buffers.
Any buffer which has any of these permissions set will be automatically copied by the filter system to a new buffer which does not have those permissions. This can be used to easily disallow buffers with AV_PERM_REUSE.
Input pads only.
Definition at line 277 of file avfilter.h.
Referenced by avfilter_start_frame().
Frame request callback.
A call to this should result in at least one frame being output over the given link. This should return zero on success, and another value on error.
Output video pads only.
Callback called before passing the first slice of a new frame.
If NULL, the filter layer will default to storing a reference to the picture inside the link structure.
Input video pads only.
Referenced by avfilter_start_frame().
AVFilterPad type.
Only video supported now, hopefully someone will add audio in the future.
Definition at line 257 of file avfilter.h. | http://ffmpeg.org/doxygen/0.5/structAVFilterPad.html | CC-MAIN-2018-05 | en | refinedweb |
#include "avformat.h"
#include "internal.h"
#include "libavutil/avstring.h"
Go to the source code of this file.
Definition in file iss.c.
Definition at line 33 of file iss.c.
Referenced by iss_probe().
Definition at line 34 of file iss.c.
Referenced by iss_probe().
Definition at line 35 of file iss.c.
Referenced by iss_read_header().
Definition at line 42 of file iss.c.
Referenced by iss_read_header().
Initial value:
{ .name = "iss", .long_name = NULL_IF_CONFIG_SMALL("Funcom ISS"), .priv_data_size = sizeof(IssDemuxContext), .read_probe = iss_probe, .read_header = iss_read_header, .read_packet = iss_read_packet, }
Definition at line 130 of file iss.c. | http://ffmpeg.org/doxygen/1.0/iss_8c.html | CC-MAIN-2018-05 | en | refinedweb |
On Fri, Aug 25, 2017 at 4:59 PM, Julian Foad <julianfoad_at_apache.org> wrote:
> Johan Corveleyn wrote:
>> On Fri, Aug 25, 2017 at 3:33 PM, Julian Foad <julianfoad_at_apache.org> wrote:
> [...]>> The Checkpoint feature could add the copy-and-modify facility
> for the
>>> log message.
>>
>> Yes, maybe we'll need to have some grouping structure / namespacing in
>> the shelves for this. A "rack" or something :-). The rack carries a
>> name ("savepoints", "feature A"); a single shelf in a rack is just
>> 'svn shelve --rack "feature A"'; If I add more shelves to a rack, they
>> get numbered. [...]
> I think the terminology works best, and most in line with other tools
> (p4, hg, bzr) like this:
>
> * "Shelving" or "to shelve" means putting something on a shelf. There
> is one "shelf" per WC.
>
> * The thing we put on the shelf is called a "patch" or a "shelved
> change", and is analogous to a book or a paper placed on the shelf. A
> numbered version of a patch can be called a "checkpoint".
>
> * A series of checkpoint patches is a series of "patch versions" or a
> "checkpoint series". I think this is simpler than introducing a new term.
Ah yes, of course. Sorry, no need to invent a new term.
Just wondering then, when we create a "series of patches" that belong
together, that have some ordering, how do we organize that?
Still only one shelf per WC (*the* shelf)? Grouping them through
naming ("savepoint-1", "savepoint-2" are two shelved patches belonging
to the same series, but "featureA" (which was reverted) is separate
because it doesn't have the same prefix)? Or do we need multiple
shelves with some name too?
Just one more thought: in the namespace of shelved changes, we might
want to reserve "svn:" or some such prefix, for internal use, to give
us possibilities for features built upon the shelving infrastructure.
--
Johan
This is an archived mail posted to the Subversion Dev
mailing list. | https://svn.haxx.se/dev/archive-2017-08/0154.shtml | CC-MAIN-2018-05 | en | refinedweb |
Custom container class storing objects of any type
Final project of the subject object oriented programming
Design
The vessel class is responsible for the collection of stored objects of any type, in this program it stores objects representing pastry shops with specific attributes and methods.
Dependencies
#include <iostream> #include <cstdlib> #include <string> #include <iterator> #include <fstream> #include <sstream> #include <iomanip>
About
The project was necessary to initially create a class, which was then modified and extended. The main class itself is the “cukiernia” class that represents the physical confectionery and its elements, such as the types of cakes sold, the working confectioners, or the street where it is located. The exercise itself was intended to introduce the object-oriented approach. | https://cpp.codetea.com/final-project-of-the-subject-object-oriented-programming/ | CC-MAIN-2022-40 | en | refinedweb |
IRC log of tagmem on 2003-07-22
Timestamps are in UTC.
15:14:05 [RRSAgent]
RRSAgent has joined #tagmem
15:16:26 [DanC-AIM]
DanC-AIM has joined #tagmem
15:17:10 [DanC-AIM]
Hi from Rosie's.
15:17:27 [DanC-AIM]
Ping?
15:18:34 [TBray]
TBray has joined #tagmem
15:19:09 [IanYVR]
Hi Dan
15:20:44 [Norm]
Norm has joined #tagmem
15:22:19 [DanC-AIM]
Hi. I'm walking over.
15:22:20 [Roy]
Roy has joined #tagmem
15:22:38 [DanC-AIM]
Zakim, who's here?
15:22:38 [Zakim]
sorry, DanC-AIM, I don't know what conference this is
15:22:39 [Zakim]
On IRC I see Roy, Norm, TBray, DanC-AIM, RRSAgent, Zakim, IanYVR
15:23:33 [IanYVR]
Roll call: TBL, NW, TB, RF, DO, PC, SW, IJ
15:23:51 [IanYVR]
Agenda:
15:24:05 [IanYVR]
Section 4 of agenda
15:24:18 [Stuart]
Stuart has joined #tagmem
15:24:23 [IanYVR]
TBray: I think that for issues 7, 20, 24, 31, 37, there is enough info in arch doc.
15:25:57 [Norm]
Norm has changed the topic to:
15:26:07 [IanYVR]
[Process discussion around last call]
15:26:59 [IanYVR]
PC: Need to schedule last call with groups where there are dependencies
15:27:37 [DanC-AIM]
Hmm... How to ask IETF to review it?
15:29:04 [DaveO]
DaveO has joined #tagmem
15:29:07 [IanYVR]
TBL: If there's a group where you know there are issues, resolve those before last call.
15:29:36 [IanYVR]
TBL: Don't say "we think we're done" while people are still banging on the document on the list.
15:30:42 [IanYVR]
TBray: If we wait to go to last call before reaching consensus with web ont folks, that's going to take a long time.
15:31:03 [IanYVR]
TBL: We have an elephant in the room. People are telling us we're not using terms consistently.
15:31:28 [DanC-AIM]
same room today?
15:31:35 [IanYVR]
TBL: Namely, "resource" is being used in two different ways that makes the document unreadable (issue 14).
15:31:53 [DanC-AIM]
Should I ring the schemasoft door or the antarctica door?
15:32:07 [IanYVR]
You can get all the way to the door of the ping pong room
15:32:24 [IanYVR]
DO: I think you can elicit the problem without solving.
15:32:37 [DanC-AIM]
From the entrance on homer?
15:32:39 [IanYVR]
Yes
15:33:16 [IanYVR]
PC: Unlike other groups, we will have open issues when we go to last call.
15:33:46 [IanYVR]
[Chris joins]
15:33:52 [DaveO]
q+
15:34:08 [IanYVR]
[DanC joins]
15:34:47 [Stuart]
q?
15:35:46 [Stuart]
ack Dave0
15:36:03 [TBray]
q+
15:36:33 [IanYVR]
DO: I think we need to explain to people why arch doc is different from other specs.
15:36:48 [IanYVR]
CL: The model is that we have a stream of issue and we gradually refine the document over time.
15:37:13 [Stuart]
q?
15:37:21 [Stuart]
ack TBray
15:37:59 [IanYVR]
TBray: I think that we still can benefit the community by publishing something that's not complete.
15:38:08 [DavidOrch]
DavidOrch has joined #tagmem
15:38:14 [DavidOrch]
q?
15:38:29 [Stuart]
ack Dave0
15:39:08 [IanYVR]
DO: Need to explain why we chose to stop where we did for v1.
15:40:04 [IanYVR]
PC: Need to explain to people also that we expect to skip CR.
15:40:19 [DavidOrch]
And say that there will be a V2..
15:40:24 [DanC_jam]
DanC_jam has joined #tagmem
15:40:52 [IanYVR]
TBray: We could call this web arch level 0
15:42:03 [IanYVR]
PC: Question of whether to create a new mailing list just for last call comments.
15:42:21 [DavidOrch]
q-
15:42:39 [IanYVR]
q- DaveO
15:42:55 [IanYVR]
PC: I prefer a separate comments list.
15:43:04 [IanYVR]
SW: Me too, with discussion on www-tag
15:43:22 [IanYVR]
TBray: It's going to be hard from keeping discussion going on last call list.
15:44:37 [IanYVR]
PC: Create a monitored list and force every message to be permitted.
15:45:50 [IanYVR]
DC: I agree that cross-posted threads are a pain.
15:46:58 [DanC_jam]
hmm... a moderated list isn't a bad idea... we'll pretty much have to do the equivalent of moderating it anyway
15:47:35 [Norm]
Norm has joined #tagmem
15:48:45 [IanYVR]
"www-tag-review"
15:48:53 [IanYVR]
s/www/public
15:49:03 [DanC_jam]
yeah... public-webarch-comments@w3.org
15:49:55 [IanYVR]
SW: Cost of going to last call on group: increased tracking of issues on doc, ongoing agenda item
15:50:22 [IanYVR]
TBL: It's my opinion that the document is imperfect and we're saying we want to take to last call anyway.
15:50:33 [IanYVR]
TBray: It's incomplete, but I think good enough to go to last call.
15:51:03 [IanYVR]
RF: Last call fine with me. I think it needs a lot of work, but I think it's useful for the process to put out a draft.
15:51:17 [TBray]
TBray: What we have is consistent and essentially correct, but not complete
15:51:22 [IanYVR]
TBL: That's not a last call draft, that's a draft.
15:51:30 [IanYVR]
[TBL comment to RF]
15:52:49 [DanC_jam]
(where are we in the agenda?)
15:53:44 [IanYVR]
Tues morning: Arch Doc
15:55:33 [TBray]
q+
15:55:52 [TBray]
q+ Paul
15:56:13 [IanYVR]
TBL: (Re httpRange-14) I feel that if we don't address this, this will be like the effect of the XML Namespaces Rec ambiguity.
15:56:42 [DaveO]
q+
15:56:44 [DanC_jam]
ack danc'
15:56:47 [DanC_jam]
ack danc
15:56:47 [Zakim]
DanC_jam, you wanted to suggest that we *do* take advantage of Candidate Recommendation
15:57:10 [IanYVR]
DC: I think CR would be a good idea. The doc's intended to have an effect; we can test whether it has the intended effect.
15:57:13 [Chris]
Chris has joined #tagmem
15:57:21 [TimBL-YVR]
TimBL-YVR has joined #tagmem
15:57:22 [IanYVR]
PC: What's the success criterion?
15:58:09 [IanYVR]
DC: Yes, I think we can find groups to use the document.
15:58:23 [IanYVR]
TBL: XML Schema had a similar issue.
15:58:30 [Chris]
Chris has joined #tagmem
15:59:05 [IanYVR]
PC: The infoset spec from XML Core is an example of a spec that you don't implement; you reference normatively. The Core WG left CR when referred to normatively from other specs.
15:59:19 [IanYVR]
PC: Perhaps that's the best we can hope for.
15:59:23 [IanYVR]
ack TBray
15:59:45 [IanYVR]
TBray: I think we should go to last call sooner rather than later. I think a lot of what we've written hasn't been written down in one place before.
16:00:14 [IanYVR]
TBray: I also perceive that the areas where we lack consensus all involve a layer that is "above" where we are now.
16:00:29 [IanYVR]
TBray: These are additional constraints imposed on what we've said already. And layer cleanly.
16:00:52 [IanYVR]
TBray: While I accept that the document does not reflect a reality shared by some, I'm convinced that there's nothing in their that hinders them in their goals.
16:00:56 [TimBL-YVR]
q+
16:01:24 [Norm]
Norm has joined #tagmem
16:01:55 [IanYVR]
RF: Pay Hayes' comments were that RFC2396 covers an information space that is larger than that covered by the Arch Doc.
16:02:27 [TBray]
q+ Paul
16:03:53 [IanYVR]
RF: Pat is not "actually confused"; it's that the Web Arch document doesn't cover the entire space of the Web. He was saying that if you restrict your discussion to information resources, then the document makes sense. It also makes sense if you limit the scope to the information system that is the classic Web. But it doesn't if you include the infosystems that are the sem web or web services.
16:04:14 [IanYVR]
TBL: I believe that the document should not go to last call without this issue resolved.
16:04:16 [IanYVR]
ack Paul
16:04:40 [TimBL-YVR]
X-Archived-At:
16:04:48 [TimBL-YVR]
Pat's message
16:05:07 [IanYVR]
PC Summarizing his interpretation: There's a thread on www-tag that TBL thinks needs to be resolved before we go to last call. Do you think that thread is separable from httpRange-14?
16:05:09 [IanYVR]
TBL: No.
16:05:42 [IanYVR]
TBL: I think the change to the document is fairly easy: introduce "information resource" where appropriate.
16:08:07 [IanYVR]
TBL: I don't know what the solution to the issue is. Perhaps we could resolve Pat's issue without mentioning HTTP. I don't know what the form the result would take.
16:08:11 [TBray]
q+
16:08:28 [IanYVR]
DO: I'm disappointed that this is coming up.
16:09:08 [IanYVR]
DO: We told AC we were going to last call, agreed this would not be on the agenda, and now there's a sort of veto.
16:09:16 [Stuart]
ack DO
16:09:21 [DaveO]
q-
16:09:22 [Stuart]
ack DaveO
16:09:28 [DanC_jam]
ack timbl
16:09:31 [TimBL-YVR]
TBL: However, the issue is SO close to hhtp-range-14 that we couldn't discuss one wiithoyt being allowed to discuss the other.
16:09:32 [IanYVR]
TBL: We could apologize up front that we use the term in two different ways. I might be able to live with last call if there's a red flag at the front of the document.
16:09:37 [Stuart]
ack TBray
16:10:24 [IanYVR]
TBray: I think that Pat Hayes' comment is wrong. I can produce counter-examples. I think his assertion that we are using the term "resource" in two different ways is wrong. I think the document is consistent.
16:11:46 [IanYVR]
ack DanC
16:11:46 [Zakim]
DanC_jam, you wanted to say I disagree with PatH as well; the webarch doc is consistent; but I think it would be cost effective to try the 'information resource' edit; not that
16:11:50 [Zakim]
... costly and could satisfy a lot more readers
16:12:06 [IanYVR]
DC: I disagree with Pat as well. I still think it would be cost-effective to talk about both classes of resources. Lots of people have that angst and that's our audience.
16:12:27 [Chris]
is that just renaming one use, or both uses?
16:12:32 [IanYVR]
q?
16:13:01 [IanYVR]
[Break]
16:20:17 [Norm]
Norm has joined #tagmem
16:50:15 [IanYVR]
[Resume]
16:52:12 [IanYVR]
TBray: I've seen no evidence to convince me that if we proceed with this draft, we are cutting off options.
16:52:44 [IanYVR]
TBray: We don't say much about "what a resource is"; we impose no constraints.
16:52:47 [Norm]
Norm has joined #tagmem
16:52:58 [IanYVR]
TBray: People point out that in the real world there are constraints.
16:53:10 [IanYVR]
TBray: We don't say that and I think that we're right not to make that distinction.
16:53:26 [IanYVR]
TBray: There are a number of taxonomies we could choose for categorizing resources.
16:53:47 [IanYVR]
TBray: I can give you examples of things that are resources but you'd have to stretch to think that they're information resources.
16:54:11 [IanYVR]
TBray: There are other taxonomies that are at least as interesting: class of resources published by hostile govts. for example.
16:54:25 [DaveO]
DaveO has joined #tagmem
16:54:26 [IanYVR]
TBray: I agree that we need a better way to talk about taxonomies of URIs.
16:54:31 [DaveO]
q?
16:54:44 [IanYVR]
TBray: Our formalism is well defined: URI, resource, representation.
16:54:50 [DaveO]
q+
16:55:10 [IanYVR]
TBray: The Web today doesn't have a way to talk about whether something is an information resource, and the software all works fine.
16:55:36 [IanYVR]
TBray: I think that the document is well-enough along, passes the minimal progress necessary to declare victory.
16:55:52 [IanYVR]
TBray: We can't ignore the angst; we need to say something about it, but we don't need to make a big change.
16:56:03 [IanYVR]
ack DaveO
16:56:31 [IanYVR]
DO: I think most of the TAG feels we don't need to solve httpRange-14 before going to last call. Clearly TBL does.
16:57:13 [TBray]
nope
16:57:25 [TBray]
q?
16:57:43 [IanYVR]
[Process discussion]
17:00:29 [IanYVR]
DO: I have concerns about the process. What does my vote mean? TBL has the last word anyway.
17:00:35 [IanYVR]
DC: Yes, and you signed up for the group knowing htat.
17:00:49 [IanYVR]
TBL: I am definitely uncomfortable when my technical role and my process role overlap.
17:01:04 [IanYVR]
DO: We are trying hard not to put TBL in that position.
17:01:08 [Stuart]
q+
17:01:13 [TBray]
q+ Stuart
17:01:29 [TBray]
q+ Stuart
17:01:33 [IanYVR]
TBL: I have avoided talking about an issue that I think is fundamental for the last year. I've not acted in my role as Director as I'd like the group to reach consensus.
17:01:42 [IanYVR]
TBL: I'm not sure that ignoring the issue is the solution.
17:01:44 [IanYVR]
ack Stuart
17:02:01 [IanYVR]
SW: I note that httpRange-14 is open (from Feb 2003) even if not on this agenda.
17:02:42 [DaveO]
I also said that we just may have to vote and then live with a Director prohibiting Last Call publication, if he chooses to exercise that authority.
17:03:01 [IanYVR]
q?
17:03:43 [IanYVR]
PC: Director doesn't gate advancement to Last Call.
17:06:08 [IanYVR]
Straw poll: Does TAG wish to advance arch doc to last call substantially as is (with some editorial changes).
17:08:15 [IanYVR]
DC: I'm not satisfied with how issue 20 is handled in 16 July draft
17:08:53 [IanYVR]
IJ: See "User agents should detect such inconsistencies but should not resolve them without involving the user (e.g., by securing permission or at least providing notification). User agents must not silently ignore authoritative server metadata."
17:09:02 [IanYVR]
DC: That's not enough about error-handling.
17:09:39 [IanYVR]
DC: Before reviewing the doc in substance, I'm not prepared to say "go forward"
17:10:51 [IanYVR]
Straw poll: 5 move forward, 1+.5+.5 against, 1 abstain
17:12:22 [Stuart]
)q?
17:12:24 [DanC_jam]
DanC: I want the arch doc to say "silent recovery from errors considered harmful" and say that louder than "data format specs should say what to do in the presence of errors"
17:12:34 [Stuart]
q?
17:13:54 [IanYVR]
RF: It's hard to write down principles of things that have not been deployed.
17:14:30 [IanYVR]
Review of
[16 July draft]
17:15:08 [IanYVR]
1. Introduction
17:15:38 [IanYVR]
DC: Lots of terms get bolded. Please bold "Web".
17:15:48 [IanYVR]
DC: What are we doing with Editor's notes?
17:15:57 [IanYVR]
"Editor's note: Todo: Introduce notions of client and server. Relation of client to agent and user agent. Relation of server to resource owner."
17:16:05 [IanYVR]
DC: I don't think that that's critical.
17:16:13 [IanYVR]
TBray: Seems appropriate for section 4 when it arrives.
17:16:15 [IanYVR]
DC: I like the intor.
17:16:17 [IanYVR]
TBray: Me too.
17:16:43 [IanYVR]
1.1. About this Document
17:17:23 [IanYVR]
RF: I don't understand why there's a 1.1 and 1.1.1
17:18:07 [IanYVR]
Idea: create 1.1.x on intended audience or drop 1.1.1. subheading.
17:18:43 [Chris]
q+ to worry about "3. The representation consists those bits that would not change regardless of the transfer protocol used to exchange them.
17:18:43 [Chris]
"
17:18:46 [IanYVR]
IJ: I will try to integrate scenario more into section 2.
17:19:17 [IanYVR]
TBray: s/The TAG/This document is intended to inform...
17:19:32 [IanYVR]
(same for second "TAG" instance later in third para of 1.1.1)
17:19:38 [IanYVR]
DC: Paste some of that into status section.
17:19:49 [IanYVR]
2. Identification and Resources
17:19:51 [Chris]
q+ to note objection on record to "User agents must not silently ignore authoritative server metadata.
17:19:51 [Chris]
"
17:20:21 [IanYVR]
TBray: Need to reword Principle: "Use URIs: All important resources SHOULD be identified by a URI."
17:20:38 [IanYVR]
DC: The doc doesn't say "if it doesn't have a URI, that doesn't mean it's not a resource."
17:20:58 [Chris]
q+ to request clarification on "3.2 and semantics"
17:21:32 [IanYVR]
RF: I have a rewrite of paragraph "Although there's not precise..."
17:23:13 [IanYVR]
RF: Don't mix up "identity" and "identify". Something can have identity (or many identities). There are means of identification (N-to-1) to those things.
17:23:34 [IanYVR]
TBray: I would be comfortable saying "URIs should be assigned for all important resources."
17:23:53 [Chris]
q+ to agree with dan about "Specifications of data formats SHOULD be clear about behavior in the presence of errors. It is reasonable to specify that errors should be worked around, or should result in the termination of a transaction or session. It is not acceptable for the behavior in the face of errors to be left unspecified."
17:23:53 [IanYVR]
[Discussion of identify/denote/name]
17:24:13 [IanYVR]
TBL: Not all URIs are necessarily assigned.
17:24:16 [IanYVR]
(e.g., hashes)
17:24:23 [IanYVR]
TBL: Only in delegated spaces.
17:24:27 [IanYVR]
RF: That's still assignment.
17:24:45 [IanYVR]
TBray: Right, at the end of the day you end up with a string that has been assigned to some resource.
17:25:15 [IanYVR]
DC: I support TB proposed wording changed.
17:25:28 [IanYVR]
TBray: The reason I'm proposing this is to stay away from the word "identity".
17:25:36 [Norm]
Norm has joined #tagmem
17:26:04 [IanYVR]
DC: "Assign" is useful. The question is WHO should do something. I think therefore that "assign" is a step in the right direction.
17:26:36 [IanYVR]
DC: The idea is that if everybody shares, we all win.
17:26:42 [Stuart]
q?
17:27:16 [IanYVR]
TBL: It would help a lot if we say "Identifier" here is used in the sense of "naming".
17:27:32 [IanYVR]
TBL: The difference is that Tim Bray is named by "Tim Bray", though he can also be identified by his flashy shirt.
17:28:37 [IanYVR]
TBray: I would be comfortable saying "using id in the sense of name". I am more worried about "denote".
17:28:39 [IanYVR]
DC: I concur.
17:28:50 [IanYVR]
DC: I think "name" helps and "denote" doesn't (without lots of explanation).
17:29:02 [IanYVR]
DC: Actually, maybe "denote" would be incorrect.
17:29:37 [IanYVR]
[We read a paragraph that RF has written on this section]
17:30:57 [IanYVR]
PC: I am wondering whether we might say something nearer to the top about "stable" URIs.
17:32:26 [IanYVR]
PC: Feature of "stability" is also an aspect of importance.
17:32:34 [Chris]
it all hinges on an appropriate definition of 'consistency'
17:33:12 [IanYVR]
TBL: I'm not happy with RF's text.
17:33:36 [TimBL-YVR]
s/produce or consume/convey/
17:34:45 [IanYVR]
TBL: RF's text doesn't address sem web resources.
17:34:47 [TBray]
q+
17:35:11 [DanC_jam]
ack chris
17:35:11 [Zakim]
Chris, you wanted to worry about "3. The representation consists those bits that would not change regardless of the transfer protocol used to exchange them. and to note objection
17:35:14 [Zakim]
... on record to "User agents must not silently ignore authoritative server metadata. and to request clarification on "3.2 and semantics" and to agree with dan about
17:35:17 [Zakim]
... "Specifications of data formats SHOULD be clear about behavior in the presence of errors. It is reasonable to specify that errors should be worked around, or should result in
17:35:21 [Zakim]
... the termination of a transaction or session. It is not acceptable for the behavior in the face of errors to be left unspecified."
17:35:40 [IanYVR]
TBray: General remark on the document - People are going to take this document seriously. There will be lots of debates.
17:35:54 [IanYVR]
TBray: One of the ways we should be careful is to take out sentences that don't need to be here.
17:36:03 [Chris]
rrsagent, pointer?
17:36:03 [RRSAgent]
See
17:36:03 [TimBL-YVR]
q+
17:36:12 [IanYVR]
TBray: Every sentence that is not contentful should be removed.
17:36:47 [IanYVR]
TBL: I feel that the namespaces spec would have been improved on if some of those sentences had not been removed. I don't want us to follow that path.
17:37:10 [IanYVR]
q+ to talk about "on the Web" in RF's text.
17:37:32 [IanYVR]
RF: Delete "transclude all or part of it into another resource." You can do transclusion without a URI.
17:37:47 [IanYVR]
RF: Transclusion is not a rationale for many people.
17:37:51 [IanYVR]
DC: I disagree.
17:38:00 [IanYVR]
TBray: Purists will debate our use here.
17:38:13 [IanYVR]
RF: Say instead "include by reference."
17:38:15 [IanYVR]
DC: Yes.
17:38:28 [IanYVR]
RF: Delete last para of 2 (before 2.1)
17:39:58 [IanYVR]
TBL: The second paragraph of 2 is where you would put in the distinction about an information resource.
17:40:49 [IanYVR]
TBL: "A resource can be anything. Certain resources convey information when a resource has a link to another one."
17:40:53 [IanYVR]
q?
17:41:12 [IanYVR]
TBray: Would it meet TBL's needs to ack the class of information resources?
17:42:29 [IanYVR]
TBray: I suggest that we say that the universe of resources has a subset which we will call "information resources" that convey information. And stop there. We ack the distinction but don't put all HTTP URIs on one side of the border or the other.
17:42:36 [IanYVR]
CL: Add "electronic"?
17:42:44 [IanYVR]
TBL: No, could transfer via light, for example.
17:43:03 [Chris]
not about transfer, about category of information
17:43:07 [Chris]
but okay
17:43:33 [IanYVR]
IJ: About "on the Web"
17:43:47 [IanYVR]
TBray: I think "information resource" is isomorphic to DO's concept of "on the Web"
17:44:43 [IanYVR]
[Question of whether "on the Web" means "really does have a representation that is available"
17:45:09 [IanYVR]
TBL: From the semantic Web point of view, things are on the semantic Web from the moment you use the URI.
17:45:23 [IanYVR]
TBL: But in the common parlance, I think "it really does work" for information objects.
17:45:34 [IanYVR]
CL: In the common parlance, electronic is also understood...
17:45:48 [Chris]
the common parlance thus applies excluusively to electronic information objects
17:46:49 [IanYVR]
DO: I want "information resource" connected to "on the Web" in the document.
17:46:56 [TimBL-YVR]
URIs identify resources. A resource can be be anything. Certain resources are information resources, which convey information. These are termed information resources. Much of this document discusses information resources, often using the term resource.
17:47:33 [DanC_jam]
Bray: I like that parap
17:48:07 [DanC_jam]
DanC: it doesn't discuss "on the web". hmm...
17:48:10 [TimBL-YVR]
An information resource is on the Web when it can be accessed in practice.
17:48:13 [Chris]
last sentence, change to "Much of this document, while discussing resources in general, applies primarily or most obviously toinformation resources"
17:48:27 [TBray]
+1 to Chris
17:48:34 [Chris]
changes from an apology to an explanation
17:49:02 [IanYVR]
IJ: I can work with "on the Web" as a parenthetical remark tieing into other terms, but I don't think it needs to identify a formal part of the architecture and I don't imagine it being used later in the document.
17:49:22 [TimBL-YVR]
q+
17:49:24 [IanYVR]
DO: I think the definition should stay away from actual availability.
17:49:38 [Chris]
ian, wsa does indeed want to use it as a defined term, I understand
17:49:51 [IanYVR]
DO: Fine by me to say that there's a general expectation that a representatoin will be available.
17:50:02 [DaveO]
Indeed, SOAP 1.2 does use the term "on the web".
17:51:28 [Roy]
I don't think that there is an information resource and non-information resource. I think that some resources are accessible on the Web information system and others are not (or are only indirectly accessible). That is because anything that has state is an information-bearing resource, but you may not have access to that information.
17:52:27 [DanC_jam]
ack danc
17:52:27 [Zakim]
DanC_jam, you wanted to ask for the figure to go in section 1 or 2; it has the word "identifies"
17:52:28 [IanYVR]
q- IanYVR
17:52:54 [IanYVR]
DC: The word "identify" is used in the illustration I'd like to see in section 1 or 2. I'd like the label "identifies" in the figure.
17:53:04 [IanYVR]
RF: That is Pat Hayes' objection. You can argue it with him.
17:53:09 [IanYVR]
Review of diagram
17:53:22 [IanYVR]
from SW
17:54:16 [Chris]
17:54:30 [IanYVR]
PC: What does "is a" mean.
17:54:37 [IanYVR]
DC: I believe it's clear enough.
17:54:47 [IanYVR]
TB, RF: Diagram doesn't add much.
17:55:33 [Chris]
actually,
17:55:36 [Chris]
17:55:44 [IanYVR]
TBray: Change camel case to English
17:55:45 [TimBL-YVR]
17:55:45 [Chris]
no good reason that is not public
17:55:46 [IanYVR]
[Support for that]
17:57:46 [IanYVR]
IJ: I would like to simplify diagram by removing dotted arrows
17:58:35 [IanYVR]
DC: It's critical that there be three things in the diagram. A lot of people miss that point.
18:00:20 [IanYVR]
Action CL: Redraw diagram with (1) English words (2) no more isa arrows; just label objects
18:01:23 [Chris]
ok since we just redrew it on the whiteboard, I won't send the old one to the public list but instead, the simplified new one
18:03:00 [DanC_jam]
Ian: yes, I intend to make "on the web" a term
18:03:08 [IanYVR]
TBray: Please lose "exponentially" in para 2.
18:03:23 [IanYVR]
DC: The point is that it's non-linearly.
18:03:30 [IanYVR]
TBL: use "dramatically"
18:03:57 [IanYVR]
DC: There's a lot of data to back up "exponential"
18:04:20 [IanYVR]
[No change]
18:04:26 [TimBL-YVR]
18:04:31 [IanYVR]
[i.e., leave "exponential"]
18:05:04 [IanYVR]
2.1. Comparing Identifiers
18:05:19 [IanYVR]
RF: I think this isn't true: "An important aspect of communication is to be able to establish when two parties are talking about the same thing."
18:05:43 [IanYVR]
RF: It's an important aspect of someone else observing that they are talking about the same thing.
18:06:09 [TBray]
18:06:37 [TBray]
2.1 Awkward start. Communication between parties is facilitated by the ability to establish when they are talking about the same thing. Then lose the second sentence.
18:07:16 [IanYVR]
TBL: Parties don't identify. They talk about or refer to. They don't identify.
18:07:43 [Chris]
+1 to timbl because context of use is important
18:08:38 [IanYVR]
Delete "In the context of the Web, this means when two parties identify the same resource."
18:08:49 [IanYVR]
TBL: Say "two parties are referring to the same resource" in following sentence.
18:08:58 [IanYVR]
DC: "Most straightforward' instead of "most common"
18:09:07 [IanYVR]
RF: Delete "Depending on the application, an agent may invest more processing effort to reduce the likelihood of a false negative (i.e., two URIs identify the same resource, but that was not detected).
18:09:07 [IanYVR]
"
18:09:14 [IanYVR]
RF: It's covered better in the URI spec.
18:09:24 [IanYVR]
TBray: Anybody who cares about this really needs to read [URI]
18:09:28 [IanYVR]
DC: I'm happy to delete that sentence.
18:09:32 [DanC_jam]
pls change "The most common" to "The most straightforward"
18:10:28 [IanYVR]
TBL: I think that the last sentence is useful since it lets people know that there is a risk of false negatives.
18:10:48 [IanYVR]
TBray: Yes, it's worthwhile saying that false negs can occur; for details look at [URI]
18:12:30 [IanYVR]
CL: Some apps are more sensitive to false positives, some more sensitive to false negs; choose wisely.
18:14:29 [IanYVR]
Action IJ: Fidget with this text.
18:14:49 [IanYVR]
Editor's note: Dan Connolly has suggested the term "coreference" instead of "equivalence" to communicate that two URIs are referring to the same resource.
18:14:59 [IanYVR]
DC: I can live without that change.
18:15:54 [TimBL-YVR]
"coreference" isin the same class as "denote" - we had decided not to use technical terms.
18:17:05 [IanYVR]
2.1. Comparing Identifiers
18:17:10 [IanYVR]
TBray: There are two side trips into URI opacity
18:17:36 [IanYVR]
TBray: I think that we need to discuss separately (1) comparing and (2) looking inside
18:17:59 [IanYVR]
NW: "In general, determine the meaning of a resource by inspection of a URI that identifies it."
18:18:13 [IanYVR]
NW: I'll provide words...
18:19:11 [IanYVR]
CL: "Although that it's tempting to infer this by looking at the URI that it is about..."
18:19:33 [IanYVR]
TBL: "...not licensed by the specs..."
18:19:50 [TimBL-YVR]
<- updated
18:20:55 [IanYVR]
IJ: I'll try to create a section on opacity out of some text in 2.1
18:21:41 [IanYVR]
[Agenda comment: Substantial sentiment to continue walking through arch doc until we get done]
18:22:00 [DanC_jam]
[it seemed sufficient sentiment to consider it RESOLVED to me]
18:22:12 [IanYVR]
RF: Don't use the term "spelling" URIs.
18:22:46 [IanYVR]
DC: The point is that the string has to have the same characters.
18:23:49 [IanYVR]
RF: Change good practice title to "Consistent spelling or URIs"
18:23:57 [IanYVR]
IJ: What about lexical?
18:24:10 [IanYVR]
DC: Same string of characters.
18:24:25 [IanYVR]
DC: The agent should use the same string of characters as originally provided.
18:24:37 [IanYVR]
2.2. URI Schemes
18:24:59 [DanC_jam]
ACTION IJ: re-word "spelling" box
18:25:18 [IanYVR]
TBray: Why did "scheme" get changed to "scheme name"?
18:25:41 [IanYVR]
RF: If you're talking about the string before the colon, its the scheme name.
18:26:04 [IanYVR]
TBray: The *scheme* corresponds to a specification.
18:26:11 [IanYVR]
TBL: "There are other *schemes*..."
18:26:33 [IanYVR]
Action IJ: Prune instances of "scheme name" except for string component before ":".
18:27:03 [IanYVR]
RF: I use "scheme component" instead of "scheme name" for slot before ":"
18:27:04 [DanC_jam]
perhaps change "Each URI begins with a URI scheme name" to "Each URI follows a URI scheme" or ... hmm...
18:27:08 [TimBL-YVR]
q+
18:27:32 [IanYVR]
CL: s/to classify/to refer to/
18:27:39 [TimBL-YVR]
<defn>URI Scheme</defn> to be higher up in the para.
18:28:16 [IanYVR]
RF: Scheme names are always used in lowercase: "http URI"
18:28:27 [IanYVR]
TBL: I disagree; we're talking about the protocol HTTP
18:30:33 [IanYVR]
Resolved: Change "HTTP URI" to "http URI"
18:31:01 [IanYVR]
SW: s/identify identify/identify
18:31:21 [IanYVR]
SW: The scheme definitions use the verb "designate".
18:31:43 [IanYVR]
SW: If we use a different term than the spec we are referring to, that's problematic.
18:31:53 [IanYVR]
DC: I think we have a good reason to use a different term.
18:33:21 [IanYVR]
Resolved: Add footnote that the other specs use the term "designate". We take "identify" and "designate" to mean the same thing.
18:33:47 [IanYVR]
[Lunch]
18:36:33 [DanC-AIM]
byebye
18:36:54 [Norm]
Norm has joined #tagmem
18:46:55 [Norm]
Norm has joined #tagmem
18:58:04 [Ralph]
Ralph has joined #tagmem
18:58:35 [Norm]
Norm has joined #tagmem
18:59:33 [Zakim]
rebooting for service pack installation
19:26:24 [ndw]
ndw has joined #tagmem
19:26:34 [DanCon]
DanCon has joined #tagmem
19:26:54 [skw]
skw has joined #tagmem
19:30:04 [Stuart]
Stuart has joined #tagmem
19:43:33 [Ian]
Ian has joined #tagmem
19:56:13 [ndw]
ndw has joined #tagmem
19:59:38 [Ian]
[Resume]
20:00:15 [Ian]
TBL: There was discussion at lunch about including more best practices.
20:01:31 [DanCon]
TBL: how about "don't use the same URI for something that's an information resource and something that's not"
20:01:37 [DanCon]
TBL: e.g. dublin core title
20:02:05 [DanCon]
(Roy also sent a problem report w.r.t. XML encryption algorithm identifiers, suggesting they should *not* contain #s. have you seen that, timbl?)
20:02:10 [Ian]
[Continuing on 2.2]
20:03:14 [Ian]
RF: "Several URI schemes incorporate identification mechanisms that pre-date the Web into this syntax:"
20:03:47 [Ian]
RF: The examples are URIs; the identification mechanism is not sufficiently targeted in that sentence to distinguish talking about the URI or the information system.
20:04:04 [Ian]
RF: I would make one big list instead of two lists.
20:04:44 [Ian]
RF: change to "incorporate information systems that predate the Web into the URI syntax..."
20:04:45 [Ian]
[Yes]
20:05:17 [Ian]
TB: "We note in passing..."
20:05:23 [Ian]
TB: Get rid of "Note in passing"
20:05:45 [Ian]
SW: IRIs are indeed proving expensive.
20:06:36 [Ian]
DC: I think the sentence is insufficiently motivated, but I can't think of anything better.
20:07:53 [Ian]
TB: I propose to delete "We note in passing that even more expensive than introducing a new URI scheme is introducing a new identification mechanism for the Web; this is considered prohibitively expensive."
20:08:47 [Ian]
[DIscussion about whether IRIs are new identification mechanism.]
20:09:38 [Ian]
TBL: s/We note in passing/Of course,/
20:09:55 [DaveO]
DaveO has joined #tagmem
20:10:06 [Ian]
TB: If we are going to make a manifesto, put it higher in the document.
20:10:45 [Ian]
Resolved: Delete "We note in passing that even more expensive than introducing a new URI scheme is introducing a new identification mechanism for the Web; this is considered prohibitively expensive." since network effect covered above.
20:11:11 [Ian]
IJ: I'll delete "When finding available based on Tim Bray's discussion of this topic, link from here.
20:11:11 [Ian]
"
20:12:10 [Ian]
RF: On "If the motivation behind registering ..."
20:12:52 [Ian]
RF: There hasn't been any demonstration that there's higher cost to registering URI scheme to registering content type.
20:14:16 [Ian]
RF: Registration process same for URI schemes and MIME types in IETF space.
20:15:20 [Ian]
CL: It's worth saying to not register new schemes that aliases and existing scheme.
20:16:02 [Chris]
Chris has joined #tagmem
20:16:05 [Chris]
q+
20:16:13 [Ian]
IJ: I would move the first bullet to section on opacity.
20:16:19 [Chris]
q?
20:16:25 [Norm]
Norm has joined #tagmem
20:16:35 [Ian]
DC: There is a choice to be made about when to register a new mime type and when to register a URI scheme.
20:17:12 [Zakim]
Zakim has joined #tagmem
20:17:14 [Chris]
q+
20:18:06 [Ian]
DC: Proposed deleting from "If the motivation " through Editor's note.
20:19:02 [Chris]
ack chris
20:19:02 [Ian]
IJ: I intend to keep the first bullet but move it.
20:19:12 [Ian]
TBL: I'd like to keep the list and add:
20:19:29 [Ian]
1) Don't invent a new protocol when one exists that gets the job done. You'd have to replicate the caching structure,
20:19:40 [Ian]
and the social behavior.
20:20:35 [Ian]
2) Cost of reinventing something is that you often make the same mistakes.
20:21:00 [TBray]
TBray has joined #tagmem
20:21:06 [Ian]
RF: I agree with these points, but they belong in the section on protocols.
20:21:08 [Ian]
TBray: I agree.
20:21:26 [DanCon]
(I'm scanning the issues list... tim's comments about re-inventing HTTP are issue HTTPSubstrate-16; what's the status of that issue?)
20:21:51 [Ian]
TBL: Don't just remove text, leave a cross ref if you move it.
20:22:01 [DanCon]
(is issue 16 on our list of issues we intend to resolve for this last call?)
20:22:28 [Ian]
RF: Once you have a new protocol, you may want to say "you SHOULD have a new URI scheme for that protocol."
20:23:26 [Ian]
q+
20:24:03 [Ian]
q-
20:24:30 [Stuart]
q?
20:24:43 [Ian]
DC: There's a time and place for new uri schemes and new media types.
20:25:24 [DanCon]
itms was a time for a new media type, not for a new URI scheme. but I'm not sure how to generalize
20:25:43 [Ian]
TBL: Don't create a new URI scheme if the properties of the identifiers and their relation to resources are covered by an existing scheme.
20:27:14 [timbl]
timbl has joined #tagmem
20:27:23 [Ian]
DC: I can tell when it's done wrong, but not sure I can write done the right thing.
20:27:31 [Ian]
PC: Even writing down the wrong thing is helpful.
20:27:44 [Ian]
DC: That's IJ's finding (from TB's blog)
20:27:53 [timbl]
The properties of the space addressed (the set of things identifiable and their relationship with the identifers) is essentially the same as any existing space, that space should be used.
20:28:11 [timbl]
s/^/If/
20:29:13 [Ian]
TB, DC: Delete first bullet "The more resource metadata is included in a URI, the more fragile the URI becomes (e.g., sensitive to changes in representation). Designers should choose URI schemes that allow them to keep their options open."
20:29:30 [Zakim]
Zakim has joined #tagmem
20:30:40 [Ian]
Resolved: Delete "Reasons for this include" through bulleted list.
20:30:50 [Ian]
2.3. URI Authority
20:30:53 [Ralph]
Ralph has left #tagmem
20:32:13 [Ian]
DC: I would have expected third paragraph in section 3.
20:32:36 [Roy]
Roy has joined #tagmem
20:32:46 [timbl]
q+
20:35:07 [timbl]
The owner of a URI defines iwhat it identifies. The web protocols allow the owner to run and control a server which provides representation, and so when such a representation has been retreived it is reasonable to take it as authoritative.
20:36:24 [Stuart]
q?
20:36:31 [Stuart]
ack timbl
20:36:36 [Ian]
TBL: There is a place here to say that, because the protocols allow the URI owner to control the server, since you have protocols, it's reasonable to hold the resource owner accountable for the representations.
20:36:59 [Ian]
TBray: I note move from "authority" to "responsibility"
20:37:21 [DanCon]
I could live without this section.
20:38:32 [Ian]
IJ: Point was to introduce authority in assignment of URIs. Later authority of producing representations.
20:39:54 [Ian]
Resolved: Delete 2.3, moving paragraphs 3 and 4 to section 3 of the document.
20:40:25 [Ian]
PC: Ensure that unused refs are deleted.
20:41:02 [Ian]
2.4. Fragment Identifiers
20:41:47 [Ian]
TBL: I think in the second paragraph that "reference to" and "with respect to" are insufficiently clear.
20:41:53 [Ian]
[We note that that text is from RFC2396bis]
20:42:08 [Ian]
TBray: I think that "with respect to that resource" is incorrect.
20:42:34 [Ian]
TBray: "Additional information that is interpreted in the context of that representation."
20:43:19 [Ian]
RF: It's with respect to the *Resource*, across all representations.
20:44:10 [TBray]
q+
20:44:15 [Ian]
Does "foo#author" mean that "author" has to mean that this is the author of the primary resource? One could read it that way.
20:44:36 [Ian]
DC: I agree that "named in" works better.
20:45:53 [Ian]
TBray: So we are asserting that the frag id is interpreted w.r.t. the resource.
20:46:06 [Ian]
DC: We are observing that, yet. There are bugs and weirdnesses out there, but they are wrong.
20:46:48 [Ian]
TBL: If you dereference a URI and get a representation back, and you know the media type, and you know the frag id semantics, then you know what is identified by the frag id.
20:47:12 [Ian]
TBL: That doesn't mean that the frag id doesn't have meaning if you don't dereference the URI.
20:48:05 [Ian]
RF: change "that is merely named with respect to the primary resource." to "named by the primary reosurce."
20:48:31 [Norm]
The fragment identifier component of a URI allows indirect
20:48:31 [Norm]
identification of a secondary resource, by reference to a primary
20:48:31 [Norm]
resource and additional identifying information that is named by
20:48:31 [Norm]
that resource. The identified secondary resource may be
20:48:31 [Norm]
some portion or subset of the primary resource, some view on
20:48:33 [Norm]
representations of the primary resource, or some other resource that
20:48:35 [Norm]
is merely named by the primary resource.
20:48:49 [Chris]
rf: delete next paragraph
20:49:08 [Chris]
'Although the generic URI syntax allows ...'
20:49:29 [Chris]
nw: see above, did we agree to this
20:49:36 [Chris]
tbl: no not really
20:49:44 [Norm]
The fragment identifier component of a URI allows indirect identification of a secondary resource by reference to a primary resource and additional identifying information that is named in that resource. The identified secondary resource may be some portion or subset of the primary resource, some view on representations of the primary resource, or some other resource that is merely named by the primary resource.
20:51:42 .
20:51:47 [timbl]
When an information resource has a URI and has a representation; and in the language of that representation a given string identifies a second resource, then the concatenation of the URI, a hash mark and the string form a URI for that second resource.
20:51:55 [DanCon]
hmm... I wonder if we came up with any good text when we worked in the wiki
20:52:03 [Chris]
it needs to tie it back to the resource fetched
20:52:39 [Chris]
lets avoid 'concatenation'
20:52:46 [Norm]
yes, please!
20:53:44 [DanCon]
why avoid 'concatenation'? that's what one does with #, no?
20:54:28 [Chris]
actually no, you split it off, stuff it in your back pocket, and then use it in isolation on what you got back
20:55:49 [DanCon]
hmm... ok, concat/split, same difference
20:56:06 [Chris]
no, pretty much opposites
20:56:51 [DanCon]
i.e. same situation, 2 different ways to describe it. if long=concat(short1, short2), then short1=split(short2 from long)
20:59:18 [Ian]
[TBL draws diagram on board showing splitting URI into frag id and URI-with-no-frag-id.]
20:59:59 [Ian]
IJ: It occurs to me we ought to re-use the initial diagram several times, successively elaborating it. E.g., when we talk about what a representation is, show the "REpresentation" piece as including metadata and data.
21:00:32 [Ian]
URI-with-hash IDENTIFIES Resource2
21:00:39 [Ian]
URI-with-no-hash IDENTIFIES Resource1
21:05:09 [Ian]
NW: I want to confirm that "#foo" means the same thing in all representations and if it doesn't it's a bug.
21:05:14 [Ian]
DC: Yes, I agree.
21:07:51 [Ian]
TBL: Not exactly. It can be reasonable to give back to types of things depending on the format returned (e.g., bank statement or HTML document that's kind of equivalent).
21:08:00 [DanCon]
(this is an issue on our list too...)
21:08:09 [Ian]
TBray: But they are functionally equivalent w.r.t. the user.
21:08:56 [DaveO]
Dan, you mean frag-id issue #28?
21:08:58 [Ian]
NW: Is it architecturally unsound to serve a format with content negotiation that does not define frag id semantics (e.g., serve HTML and PDF).
21:09:11 [Ian]
?
21:09:30 [Ian]
TBL: Browsers should say "There's no frag id".
21:09:41 [Ian]
DC: This is a silent recovery from error today.
21:10:30 [Ian]
CL: Are we saying it's an error to serve foo#bar if one representation doesn't define frag id semantics?
21:10:44 [Ian]
TBray: Not a server problem, but an authoring problem.
21:11:11 [Chris]
conneg and fragments considered incompatible
21:11:16 [timbl]
When an information resource has a URI and has a representation; and in the language of that representation a given string identifies a second resource, then the concatenation of the URI, a hash mark and the string forms a URI for that second resource. The MIME type registration defines this syntax and semantics of such a string.
21:11:30 [Ian]
See 2.4.1 for this discussion...
21:12:28 [Ian]
TBray: TBL means that the format spec defines the semantics of what the frag id is used for.
21:12:42 [DaveO]
q+
21:12:56 [Ian]
DC: I think it's easier to talk about splitting a URI rather than concatenating two parts.
21:13:11 [TBray]
ack TBray
21:14:44 [Ian]
TBray: Superfluous to say "info resource" since that's the kind that has representations.
21:15:11 [Stuart]
ack Dave0
21:15:16 [Chris]
so (to clarify) items 7 .. 11 on the agenda are hereby dropped
21:15:45 [TBray]
When a resource has a representation...
21:15:57 [timbl]
When a resource has a URI and has a representation; and in the language of that representation (using a syntax and semantics defined by the MIME type specification) a given string identifies a second resource, then the concatenation of the URI, a hash mark and the string forms a URI for that second resource.
21:16:00 [DanCon]
SIGH.
21:16:03 [Ian]
DC: I thought we were going to use the term information resource that we introduced earlier.
21:17:37 [Ian]
RF: I think that the existing text in RFC2396 is superior to TBL's proposal.
21:17:53 [Ian]
DC: I agree that the second para is better.
21:18:03 [Ian]
(ie.. existing text in arch doc)
21:18:32 [Ian]
RF: I think it's important to be able to define a resource with a URI that includes a frag id without having to get back a representation.
21:18:37 [Chris]
q+ to tak about delegated authority and fragments
21:18:55 [DaveO]
q-
21:19:30 [Norm]
Norm has joined #tagmem
21:20:25 [Norm]
How is this:
21:20:35 .
21:20:44 [Norm]
The URI that identifies the secondary resource consists of the URI of the primary resource with the additional identifying information as a fragment identifer.
21:21:10 [Ian]
[Discussion of "selecive with respect to that resource"]
21:22:39 [Stuart]
q+
21:22:56 [Ian]
RF: HOw about "that is defined by that resource" instead.
21:23:06 [Ian]
RF: The MIME type is not significant here.
21:23:42 [Ian]
DC: I think RF's current text is good, and we could also include TBL's paragraph
21:24:28 [Ian]
TBray: Can we lose the word "merely"?
21:25:44 [Ian]
DC: I am ok with Norm text, but on condition that it go into 2396bis.
21:26:04 [Stuart]
q-
21:26:05 [Ian]
TBray: I think NW's second .proposal is better than TBL's:
21:26:18 [Chris]
q?
21:26:51 [DanCon]
ack chris
21:26:51 [Zakim]
Chris, you wanted to tak about delegated authority and fragments
21:27:00 [timbl]
q+ to bzzzzzzzzzzzzzzzt vague alarm
21:27:02 [Norm]
Norm has joined #tagmem
21:27:08 [Ian]
Ian has joined #tagmem
21:27:15 [Norm]
q?
21:28:31 [Ian]
CL: You don't get to fiddle around with URIs. You do, however, get to fiddle with the fragment.
21:28:32 [DanCon]
hmm... I hear a point that chris is making... but I'm not sure how to put it into an economical number of words
21:28:48 [DaveO]
Norm, I don't understand your earlier question about #foo meaning the same thing. If WSDL defines #foo to mean an abstract component *thing*, and SVG defines #foo to mean an xml element with name foo, then they don't have the same meaning.
21:29:09 [Ian]
I also think that xpointer lets you create anchors outside the original document.
21:29:43 [Ian]
So person A can create anchor in person B's representation
21:29:44 [DanCon]
so DaveO, don't make SVG and WSDL representations that use 'foo' available for the same resources
21:30:07 [Stuart]
q?
21:30:18 [DanCon]
ack timbl
21:30:18 [Zakim]
timbl, you wanted to bzzzzzzzzzzzzzzzt vague alarm
21:30:35 [Chris]
ack chris
21:30:44 [Ian]
TBL: I find NW's alternative is still vague.
21:30:55 [Ian]
TBL: If you include my paragraph after it, I will be happy.
21:31:12 [Roy]
This is what the URI spec *also* says:
21:31:21 [Chris]
dave - svg defines barename #foo to mean the xml thing because its a +xml media type
21:31:22 [Ian]
TBL: In particular, it's important to see how URIs are the same; and how to proceed with frag id.
21:31:25 [DanCon]
(stuart/ian, did we agree to include the figure from the whiteboard?)
21:31:38 [Ian]
Chris has action to do image revision.
21:31:44 [Ian]
I'd like CL to do a version of what's on board, too
21:31:46 [Chris]
dan - I believe we did and i will draw that one, too
21:31:57 [DanCon]
thx, chris
21:32:01 [Ian]
thx chris
21:32:12 [Ian]
Proposed: Include TBL para after existing para from 2396.
21:32:33 [Ian]
TBray: I prefer NW's text to that in 2396
21:32:39 [Ian]
TBray: I accept DC's caveat.
21:33:39 [Ian]
Resolved: Accept NW's second proposed text and TBL's text.
21:34:03 [Ian]
[Break]
21:34:52 [Norm]
Norm has joined #tagmem
21:38:45 [timbl]
22:00:42 [Ian]
</break>
22:00:49 [timbl]
Wheas human communication tolerates such anbiguity, machine processing does not.
22:02:01 [Ian]
[Discussion of whether Director should say ok to advance of a spec to PR (or PER) if mime type not registered.]
22:03:16 [Ian]
How to Register a Media Type with IANA (for the IETF tree)
22:03:22 [Ian]
22:03:25 [Ian]
Does this need updating?
22:05:01 [Ian]
----
22:05:32 [Chris]
minimally yes as it speaks of the ietf tree, should be standards tree
22:05:50 [Chris]
danc mentioned email, no ID required
22:06:17 [timbl]:08:31 [DanCon]
pointer to what we're looking at for the minutes? with $Date$?
22:09:23 [Ian]
Discussion of "Although the generic URI syntax allows any URI to end with a fragment identifier, some URI schemes do not specify the use of fragment identifiers. For instance, fragment identifier usage is not specified for MAILTO URIs."
22:09:34 [Norm]
Norm has joined #tagmem
22:09:39 [Ian]
RF: This is orthogonal to the URI scheme.
22:09:50 [Ian]
TBray: It's not the scheme, it's the data formats.
22:11:39 [Ian]
Resolved delete "Although the generic URI syntax allows any URI to end with a fragment identifier, some URI schemes do not specify the use of fragment identifiers. For instance, fragment identifier usage is not specified for MAILTO URIs.
22:11:40 [Ian]
"
22:12:59 [Ian]
TBray: Please see if you can either delete 2.4.1 heading or find a second heading for 2.4
22:13:01 [Chris]
>>>>>>>>>>
<<<<<<<<<<
22:13:39 [Ian]
NW: Change in 2.4.1 "Clients should not be expected to so something..." to "It is an error..."
22:15:36 [Ian]
TBray: "It is an error condition when you have a URI with a frag id and representations don't have consistent frag id semantics..."
22:15:52 [Ian]
RF: You need to be careful: The error is not creating the identifier.
22:16:12 [Ian]
RF: You may tolerate the error in some cases.
22:16:35 [Ian]
RF: Good practice note is wrong: "Authors SHOULD NOT use HTTP content negotiation for different media types that have incompatible fragment identifier semantics."
22:18:11 [Ian]
TBray: "In the case where you use coneg to serve multiple representations, and some of those representations have inconsistent frag id semantics, then you are creating an opportunity for this error to occur."
22:18:22 [DanCon]
yes, pls strike the good practice box and replace with words ala what Bray just said
22:19:14 [Chris]
or, clarify the good practice note ... but can live with tim brays text
22:19:18 [DanCon]
NW: yup
22:19:29 [Ian]
Proposed: Revise good practice note with spirit of what TB said.
22:19:54 [Ian]
TBL: I'm ok with TB's text.
22:20:04 [Ian]
Resolved: Revise good practice note with spirit of what TB said.
22:22:19 [DanCon]
misuse from 3.3: "The simplest way to achieve this is for the namespace name to be an HTTP URI which may be dereferenced to access this material."
22:22:59 [Ian]
[Discussion of "dereference" v. "retrieve"]
22:23:06 [Roy]
q+
22:23:09 [timbl]
q+ Roy
22:23:41 [DanCon]
I like 'access' and I can live with 'retrieve' and I'd like to avoid 'dereference' if we can.
22:24:20 [Ian]
DO: Please include examples in 2.5.
22:24:24 [Norm]
Norm has joined #tagmem
22:25:01 [Ian]
TBray: I like "access" as well.
22:25:42 [Chris]
dereference is used in 2.2. URI Schemes as well
22:25:53 [Chris]
Furthermore, the URI scheme specification specifies how an agent can dereference the URI.
22:25:59 [Chris]
+1 for access
22:26:01 [Ian]
TBray: I suggest deleting "Given a URI, a system may attempt to perform a variety of operations on the resource, as might be characterized by such words as "access", "update", "replace", or "find attributes". Available operations depend on the formats and protocols that make use of URIs. "
22:27:07 [timbl]
To derefernce a URI is access the resource which it identifies.
22:27:18 [Chris]
dereference is not retrieval
22:27:29 [timbl]
necessarily
22:29:09 [DanCon]
1. rename to accessing a resource
22:29:14 [Ian]
Proposed::29:26 [DanCon]
2nded.
22:29:32 [TBray]
+1
22:29:36 [Chris]
+1
22:29:36 [Ian]
IJ: I don't agree.
22:30:36 [Ian]
IJ: +1
22:30:49 [Ian]
Resolved::32:06 [Ian]
DC: In 2.8.4, I prefer "access' over "resolution"
22:33:20 [Ian]
TBL: I think we can delete "resolution" from the document.
22:33:31 [Ian]
TBL: Use "access" instead.
22:33:35 [Ian]
NW: Delete "finite" from 2.5
22:34:15 [Ian]
Resolved: Delete resolution from document (replace with access where necessary).
22:34:19 [DanCon]
if you're gonna strike finite, you might as well strike 'set'
22:35:06 [DanCon]
("Resolved" was a bit hasty there... stand by...)
22:35:13 [Ian]
"While accessing a resource..."
22:35:32 [Ian]
Resolved: Delete resolution from document (replace with access where necessary).
22:36:55 [Ian]
2.5.1. Retrieving a Representation
22:37:29 [Chris]
Some URI schemes (e.g., the URN scheme [RFC 2141]) do not define dereference mechanisms.
22:38:30 [Chris]
is it tru (yes apparently) and does it contribute anything useful
22:39:34 [Chris]
okay, chris lets it slide
22:39:52 [Ian]
2.5.1. Retrieving a Representation
22:40:03 [Ian]
TBray: Potentially misleading - " The representations communicate the state of the resource."
22:40:23 [Ian]
TBray: Representation doesn't need to represent ENTIRE state of resource.
22:41:04 [Ian]
TBL: "Some or all of the state of the resource...."
22:41:05 [DanCon]
ed note: "As stated above" as a consequence of decisions we made recently.
22:41:20 [Ian]
Resolved: "communicate some or all of the state of the resource."
22:41:28 [Chris]
"is used within an a element " is vague
22:41:47 [Ian]
SW: Change "which representations are used" to "which content types".
22:41:50 [Ian]
DC, TB: No.
22:42:17 [Ian]
TBray: A server can throw your PUT on the floor.l
22:42:22 [Chris]
suggest 'is the value of an href attribute in the xlink namespace on an a element
22:42:30 [Ian]
DO: This section is about retrieving a representation.
22:42:36 [Ian]
SW: Comment withdrawn.
22:42:41 [TBray]
note that the "As stated above" reference no longer works since we nuked that section
22:42:44 [Chris]
q+ to say just that
22:42:48 [Chris]
q?
22:42:57 [Ian]
RF: This good practice note is out of place: "Owners of important resources SHOULD make available representations that describe those resources."
22:43:20 [timbl]
Note now dead link on "authority responsible for a URI"
22:43:48 [timbl]
s/that describe those/of those/
22:43:50 [Ian]
Change to "Resource representations: Owners of important resources SHOULD make available representations of those resource."?
22:43:59 [Stuart]
q?
22:44:07 [Chris]
q+ to say that "the SVG specification suggests " is weak, too
22:44:11 [Ian]
RF: I think that moves away from original intent: I think it was that owners should provide metadata.
22:44:18 [timbl]
q+ s/that describe those/of those/
22:44:23 [Ian]
DC: No, it was about not filling the Web with 404s.
22:44:24 [timbl]
q+ to say s/that describe those/of those/
22:44:40 [Ian]
DC: Drill in this good practice Note by giving a 404 example.
22:44:46 [Ian]
DC: And show that that sucks.
22:44:48 [Chris]
ack chris
22:44:48 [Zakim]
Chris, you wanted to say just that and to say that "the SVG specification suggests " is weak, too
22:44:52 [DaveO]
q+
22:45:02 [Stuart]
ack Roy
22:45:11 [DaveO]
q-
22:45:27 [DaveO]
q+ to mention representations retrieved by other methods than GET
22:45:37 [DanCon]
logger, pointer?
22:45:53 [DanCon]
RRSAgent, pointer?
22:45:53 [RRSAgent]
See
22:46:07 [Norm]
Norm has joined #tagmem
22:46:25 [DanCon]
22:42:22 [Chris]
22:46:25 [DanCon]
suggest 'is the value of an href attribute in the xlink namespace on an a element
22:46:54 [Ian]
IJ: Nowhere does the SVG spec say "GET".
22:46:58 [Chris]
22:47:12 [Chris]
SVG provides an 'a' element, analogous to HTML's 'a' element, to indicate links (also known as hyperlinks or Web links). SVG uses XLink ([XLink]) for all link definitions.
22:48:50 [timbl]
q+
22:50:26 [Chris]
its the xlink href in the context of the a element and the other attributes on the a element that imply
22:51:06 [Norm]
Norm has joined #tagmem
22:51:46 [timbl]
ack tim
22:51:46 [Zakim]
timbl, you wanted to say s/that describe those/of those/ and to
22:52:36 [Chris]
xlink:show = 'new | replace'
22:52:36 [Chris]
Indicates whether, upon activation of the link, traversing to the ending resource should load it in a new window, frame, pane, or other relevant presentation context or load it in the same window, frame, pane, or other relevant presentation context in which the starting resource was loaded.
22:52:43 [DaveO]
ack daveo
22:52:43 [Zakim]
DaveO, you wanted to mention representations retrieved by other methods than GET
22:53:17 [Chris]
ACTION Chris tighten this language for SVG 1.2
22:53:27 [Ian]
DO: What do we say about POST - result of POST operation is a representation (or some data).
22:53:36 [Ian]
TBL: That's not a representation of any resource.
22:53:47 [Ian]
DO: Yes, it is, I can give it a content location.
22:54:17 [Ian]
TBray: Question, e.g., of, after an update, getting a mere 200 or getting updated text (i.e., representation).
22:54:21 [Chris]
"By activating these links (by clicking with the mouse, through keyboard input, and voice commands), users may visit these resources." is vague and wooly
22:54:27 [Ian]
[Discussion of HTML forms]
22:54:57 [Ian]
DC: I disagree that what is POSTed is a representation of the resource.
22:54:59 [Chris]
prefer sections 1 and 2 bring in the other context (element name, attributes)
22:55:08 [Ian]
(yes)
22:55:21 [Chris]
ie is not just the occurence of a bare URI on some random element that makes it be a hyperlink
22:55:41 [Ian]
[Agreement on "form data"]
22:55:51 [Norm]
Norm has joined #tagmem
22:55:53 [Norm]
q?
22:55:53 [Ian]
DO: I send form data to the server. Is what I get back a representation?
22:56:00 [Chris]
ACTION Ian, Chris discuss and propose improved wording
22:56:21 [Ian]
DC: No, it's not a representation.
22:56:35 [Ian]
RF: It is a representation.
22:56:45 [Ian]
RF: It's a representation of the response that you get back.
22:56:55 [Ian]
DC: It's not a representation of any thing the common specs give a name to.
22:57:21 [TBray]
q+
22:58:20 [TBray]
q-
22:58:21 [DaveO]
I want to make sure that we say that POST results are NOT retrieval operations.
22:58:29 [Chris]
q+ to say I believe we already agreed to this - that access is not trhe same ars retrieval
22:58:38 [Chris]
post result is not a retieval action
22:58:43 [Ian]
RF: An HTTP POST is not a retrieval action.
22:59:12 [Stuart]
ack Chris
22:59:12 [Zakim]
Chris, you wanted to say I believe we already agreed to this - that access is not trhe same ars retrieval
22:59:28 [Ian]
q+ to ask what changes are being suggested in 2.5.1
22:59:46 [timbl]
An HTTP POST is not a retreival action. Any resulting response is NOT a representation of the URI posted to.
23:00:58 [Stuart]
if the resullt includes a Location header, is the result a representation of the resource referenced by the location header?
23:01:01 [DanCon]
yes, let's use POST as an example to distinguish access from retrieval
23:03:12 [Ian]
Action IJ: Include POST (and other methods) as examples of deref methods at beginning of 2.5
23:03:35 [DaveO]
stuart, I don't think a POST that "happens" to contain a Location is a "retrieval". It's a deref, that could be followed by a retrieval on the Location URI.
23:03:37 [Chris]
in other words, make a positive statement that non-retrieval access is both possible and good if appropriate
23:03:48 [Chris]
some non-HTTP examples would be good, too
23:03:49 [Ian]
Delete editor's note in 2.5.1 since "on the web" handled earlier per today's discussion.
23:03:53 [Ian]
2.5.2. Safe Interaction
23:04:07 [Ian]
[Minor editorial only]
23:04:11 [Ian]
2.6. URI Persistence
23:05:07 [Ian]
Resolved: Delete "draft" before "TAG findings" globally.
23:05:59 [Ian]
DC: "Similarly, one should not use the same URI to refer to a person and to that person's mailbox."
23:06:16 [Ian]
DC: If you ask Mark Baker are you your mailbox, he'd say yes.
23:06:54 [."
23:07:09 [Ian]
[Text provided by TBL]
23:07:47 [Ian]
TBL: s/URI persistence also/It is an error for a URI to identify two different things.
23:07:48 [Ian]
DC: No.
23:08:15 [Ian]
TBray: What about retitling section "Maximizing the usefulness of URIs"
23:08:18 [Chris]
2.6. URI Persistence > new title
23:08:30 [Chris]
sunsections persestence, ambiguity, reliability
23:08:37 [Ian]
"URI Persistence and Ambiguity"
23:09:02 [Ian]
RF: Are all uses of URIs for the sake of identification?
23:09:03 [Ian]
TBL: Yes.
23:09:15 [Ian]
RF: Identification of what?
23:09:34 [Ian]
RF: What about using a URI in a sentence as an indirect identifier: "I wonder whose home page is
"
23:09:52 [Ian]
TBL: The URI refers to the home page...
23:11:11 [Ian]
TBL: I have a problem with sentence starting "For instance...."
23:11:43 [Stuart]
see
23:12:02 [Ian]
DC: "Whoever publishes the URI should be clear about whether it identifies the book, the whale, etc."
23:12:24 [Ian]
TBL: I don't like that in this case.
23:12:31 [Ian]
TBL: I don't want them to say it's a whale.
23:14:31 [DanCon]
DC: whale? yeah... take out the whale.
23:14:36 [TBray]
q+
23:14:40 [Ian]
q-
23:15:05 [Ian]
TBray: In TBL's proposed paragraph, I disagree with a lot and don't understand some points.
23:15:15 [Chris]
proposed addition makes invalid assertions. Some machines tolerate ambiguity very well
23:15:26 [Ian]
TBray: I don't agree with a straight assertion that machines don't tolerate ambiguity.
23:15:49 [Norm]
q+
23:16:02 [Chris]
q?
23:16:49 [Stuart]
ack TBray
23:16:55 [Stuart]
ack Norm
23:17:14 [Ian]
NW: People will make conflicting assertions. The system will have to deal with this.
23:17:24 [Ian]
NW: I'm satisfied with existing text.
23:18:40 [Ian]
TBL: I think our concern is not the ambiguity of "Moby Dick" it's the inconsistent uses of the URI.
23:18:47 [DanCon]
I'm not too happy with the moby paragraph.
23:18:54 [Ian]
TBray: When you mint a URI you need to be clear about what it identifies.
23:18:59 [Ian]
TBray: Remove the quotes...
23:19:21 [Norm]
q+
23:19:46 [Ian]
DC: I'd like a positive statement about what to do.
23:19:50 [DanCon]
and strike whale
23:19:57 [Stuart]
q+ Ian
23:20:00 [timbl]
q+ to say that anything which goes in this document should be consisetnt with HTTP resources being information resources
23:20:05 [Norm]
I don't see any reason to strike whale
23:20:09 [DanCon]
ack tim
23:20:09 [Zakim]
timbl, you wanted to say that anything which goes in this document should be consisetnt with HTTP resources being information resources
23:20:43 [Ian]
TBL: I don't want to say that the URI designates whatever the URI owner wants.
23:21:02 [DanCon]
tim's correct that this para, as written, takes a position on httpRange-14.
23:21:10 [DanCon]
ack norm
23:21:33 [Ian]
NW: Could I not write an RDF assertion that says that this URI identifies the while, then another assertion that conflicts with that?
23:21:35 [Ian]
TBL: Yes.
23:21:48 [Ian]
NW: Why is this special case so important?
23:22:10 [Ian]
TBL: Important axiom for version 2 of the arch doc - referent of an HTTP resource without a hash is an information resource.
23:23:58 [Stuart]
q+ Paul
23:24:10 [Ian]
NW: RF's the standards that we write for the sake of identification is orthogonal to the systems that make use of them.
23:24:13 [DanCon]
ack ian
23:24:20 [timbl]
Tim;'s comments was not abouyt th doc, about dan's proposal
23:25:25 [Roy]
q+
23:25:36 [Roy]
ack Roy
23:26:24 [Ian]
PC: May need, for forward compatibility, to ensure that something is an error in V1 though might be more meaningful in V2 of arch doc.
23:26:28 [Norm]
And it's too late already. The cat is out of the bag.
23:26:32 [Ian]
PC: Need to include a warning at least to users.
23:26:43 [Stuart]
q?
23:26:46 [DanCon]
hmm... a health-warning about httpRange-14 is an interesting idea.
23:26:48 [Stuart]
ack Paul
23:27:14 [Ian]
PC: Do we put something in arch doc v1 that is warning that we say "Don't do this; we think that there are arch reasons to use this form for explicit meaning and we haven't yet defined that."
23:27:38 [Ian]
RF: You can replace the URI with a URN...
23:27:45 [Ian]
DC: Or put a hash and frag id it.
23:27:50 [Ian]
s/it/in it/
23:28:53 [Stuart]
q?
23:28:54 [Ian]
DC: If you ask most people if something is a whale, and people can put it in their browser, they're likely to say "Nope, that's not a whale."
23:28:58 [Stuart]
ack DanCon
23:28:58 [Zakim]
DanCon, you wanted to note that timbl's axiom may be more widely accepted than norm suggested
23:29:20 [Ian]
NW: That argument suggests that if there's a hash mark at the end of a URI and it takes them to the middle of a document, then it's not a whale either.
23:29:29 [Ian]
TBL: If it's a hypertext document, it's never a whale.
23:29:52 [Ian]
NW: So I can't serve up with coneg a hypertext doc that describes an RDF vocab and the RDF vocab.
23:29:54 [Ian]
DC: Right.
23:30:01 [Ian]
DC: That seems problematic; and we discussed that earlier.
23:30:18 [DanCon]
... in the case of WSDL and HTML
23:30:28 [Ian]
q+ TB
23:30:29 [Ian]
ack TB
23:30:50 [Ian]
TBray: I would be ok with taking "whale" out of the sentence. I'm still not convinced of TBL's axiom.
23:31:13 [DaveO]
Dan's right, same thing with namespacename#WSDLFrag-ID and the collision between RDDL vs WSDL representations at the namespace URI.
23:31:24 [Ian]
RF: Just change the scheme name...
23:31:41 [DanCon]
... too foo: ... something unregistered
23:31:46 [Ian]
TBray: What about "Melville#moby"
23:33:11 [Ian]
Action TBL: Propose a replacement to "URI persistence ...person's mailbox".
23:33:37 [Ian]
---
23:35:22 [Ian]
[TAG accepts risk that continuing walkthrough puts other agenda items at risk.]
23:36:18 [Chris]
q+ to mention 2.7
23:36:21 [Ian]
2.7. Access Control
23:36:35 [Chris]
23:36:48 [Chris]
23:37:39 [Ian]
[German govt ruling in favor of permissability of deep linking]
23:38:00 [Ian]
CL: TAG could update its finding to include a link to this.
23:38:27 [TBray]
Typo: two quotes before the word Deep ("')
23:38:28 [Ian]
Action IJ: Update Deep linking finding (new revision) with reference to this decision.
23:38:53 [Ian]
2.8. Future Directions for Identifiers
23:39:02 [DanCon]
ed: 2.8 has no text before 2.8.1
23:39:15 [Ian]
2.8.2. Determination that two URIs identify the same resource
23:39:25 [Ian]
TBray: Pay Hayes says we're wrong on this.
23:39:28 [Chris]
2.8.1 no-one had any objections to the text
23:39:28 [Ian]
DC: I disagree with him.
23:39:59 [Ian]
2.8.3. Consistency of fragment identifier semantics among different media types
23:41:01 [Chris]
2.8.3 first para on automagic fragment conversion is hazy and likely not possible in general
23:41:07 [Chris]
suggest dropping it
23:41:13 [Ian]
TBL: There was discussion in HTTP community about putting frag id in headers.
23:41:28 [Ian]
Resolved: Delete "There has been some discussion but no agreement that new access protocols should provide a means to convert fragment identifiers according to media type."
23:41:50 [Chris]
2.8.3 in entirity hits the dust
23:41:52 [Ian]
Delete 2.8.3, distributing refs to issues elsewhere.
23:42:00 [Ian]
Action DC:
23:42:08 [Ian]
Include pointers in 2.8.5 to such systems.
23:42:09 [Chris]
2.8.5 needs more clarity and pointers
23:42:13 [Ian]
(e.g., freenet)
23:42:50 [Roy]
Roy has left #tagmem
23:43:15 [Ian]
Action IJ: Add text to 2.8 before 2.8.1 giving context (e.g., work going on in community, no guarantee that TAG will do this work)
23:43:54 [Ian]
TBray: This is a survey of the landscape; not a commitment to actions.
23:44:04 [Ian]
PC: And do this in 2, 3, 4.
23:45:18 [Ian]
SW: Meeting resumes at 8:30 tomorrow. Door open at 8am
23:45:21 [Ian]
ADJOURNED
23:45:24 [Ian]
RRSAgent, stop | http://www.w3.org/2003/07/22-tagmem-irc.html | crawl-001 | en | refinedweb |
The type system is used when mapping a C++ based library onto a corresponding Java library using the Qt Jambi generator.
The developer can define the scope of the Java API by writing a type system specification. The specification is a handwritten XML document listing the types that will be available in the generated Java API; types that are not declared in the specification will be ignored along with everything that depends on them. In addition, it is possible to manipulate and modify the types and functions. It is even possible to use the type system specification to inject arbitrary code into the source files, such as an extra member function.
The type system specification is passed as an argument to the generator.
Below is a complete reference guide to the various nodes of the type system. For examples of use, take a look at the type system files used to generate the Qt Jambi API. These files can be found in the generator directory of the Qt Jambi package.
See also: Qt Jambi Generator Example
access, argument-map, conversion-rule, custom-constructor, custom-destructor, define-ownership, enum-type, extra-includes, include, inject-code, insert-template, interface-type, load-typesystem (multiple type system), modify-argument, modify-field, modify-function, namespace-type, object-type, primitive-type, reject-enum-value, rejection, remove, remove-argument, remove-default-expression, rename, replace, replace-default-expression, replace-type, suppress-warning, template, typesystem, value-type | http://doc.trolltech.com/qtjambi-4.4.0_01/doc/html/com/trolltech/qt/qtjambi-typesystem.html | crawl-001 | en | refinedweb |
IRC log of tagmem on 2003-07-21
Timestamps are in UTC.
19:55:46 [RRSAgent]
RRSAgent has joined #tagmem
19:56:48 [timbl234]
timbl234 has joined #tagmem
20:04:49 [Norm]
Norm has joined #tagmem
20:06:08 [TimBL-YVR]
20:06:13 [TimBL-YVR]
TimBL-YVR has changed the topic to:
20:12:21 [TimBL-YVR]
Agenda: 13:00 Start: setup time for those with windows
20:12:23 [TimBL-YVR]
13:10: Start for those with Linux
20:12:24 [TimBL-YVR]
13:14 Start for those with Macs
20:12:26 [TimBL-YVR]
13:15 Item one.
20:12:55 [TBray]
TBray has joined #tagmem
20:13:04 [DanC_jam]
DanC_jam has joined #tagmem
20:14:47 [Norm]
jam?
20:16:00 [IanYVR]
Resolved to thank BEA, Schemasoft, Antarctica!
20:16:17 [IanYVR]
Roll call: SW (Chair), PC, DO, TBL, NW, DC, TB, IJ (Scribe)
20:16:25 [IanYVR]
Expecting: CL, RF
20:16:36 [IanYVR]
Previous meeting 14 July
20:16:41 [IanYVR]
20:17:13 [IanYVR]
Resolved: Accept meeting of 14 July
20:17:34 [IanYVR]
Agenda:
20:18:14 [IanYVR]
SW: Several big themes: (1) Arch Doc to last call? (2) RDDL (namespaceDocument-8) (3)Close findings
20:18:42 [IanYVR]
[Review of agenda]
20:24:00 [IanYVR]
Next meeting?
20:24:51 [IanYVR]
28 July.
20:24:54 [IanYVR]
---
20:24:57 [IanYVR]
November ftf?
20:25:16 [IanYVR]
PC: The AB is not meeting on Sunday in Japan.
20:26:06 [IanYVR]
Proposal to move TAG ftf meeting - 15, 16 Nov
20:26:20 [IanYVR]
Proposal: 20, 21 Nov
20:26:24 [IanYVR]
TBL: Team day is 20 Nov
20:29:22 [DanC_jam]
so that's RESOLVED (15/16Nov) contingent on hearing from Chris, Roy.
20:30:57 [IanYVR]
---
20:32:18 [IanYVR]
20:32:46 [IanYVR]
TBray: Should XSLT that transforms RDDL to RDF be included in an appendix of RDDL Note? Should we say anything about standing of that RDF?
20:34:00 [TBray]
20:34:41 [DaveO]
DaveO has joined #tagmem
20:37:39 [IanYVR]
TBray: I have not yet created modular DTD.
20:38:05 [IanYVR]
SW: There's an issue about whether we should use XLink or not (per our other discussions about linking).
20:38:41 [IanYVR]
TBray: Original version of RDDL used XLink, but that seemed like a bad use of markup. There are well-known distinguished semantics in RDDL that would be stretching XLink semantics.
20:38:57 [IanYVR]
TBray: Also, this is the smallest possible solution, which I thought would be the best.
20:39:03 [IanYVR]
Action PC 2003/04/07: Prepare finding to answer this issue, pointing to the RDDL Note. See comments from Paul regarding TB theses.
20:39:28 [IanYVR]
20:39:31 [IanYVR]
20:40:19 [IanYVR]
TBray: My recollection is that the finding was going to (1) outline how we got here (2) say that it's a good idea to have a namespace doc and (3) RDDL is a candidate.
20:40:46 [IanYVR]
Theses:
20:40:59 [Stuart]
Stuart has joined #tagmem
20:41:20 [IanYVR]
PC: There was a sticky point in the original theses about the use of URNs.
20:41:56 [IanYVR]
PC: There is no record of the TAG agreeing with all of the theses.
20:42:02 [IanYVR]
DC: We don't have to agree with all of them.
20:42:21 [IanYVR]
TBray: I think there was broad consensus about most of them except the last couple, #5, and #6.
20:42:45 [IanYVR]
TBray: I propose that we:
20:42:58 [IanYVR]
1) With the blessing of the TAG, revise the Note to provide a more obvious example.
20:43:06 [IanYVR]
2) Dig up XSLT-to-RDF transform and put in appendix.
20:43:29 [IanYVR]
3) PC writes a finding that says namespace docs can be useful and here's a Note that defines a format specific to this application.
20:43:57 [IanYVR]
TBray: I don't think we need to address all of the theses for us to finish this issue.
20:44:10 [DanC_jam]
ack danc
20:44:10 [Zakim]
DanC_jam, you wanted to test the queue and to play thru some scenairos: RDFS, XHTML, some namespace 'defined' with an XML Schema, some WSDL example
20:44:22 [IanYVR]
DC: I'd like to (1) See three examples of RDDL since it has costs and benefits and (2) I'd like the finding to say that xml schema is another opportunity.
20:44:32 [IanYVR]
s/opportunity/option
20:44:49 [IanYVR]
DC: I'd like examples with RDFS, XHTML, XML Schema, WSDL.
20:45:54 [IanYVR]
TBray: I think that it would be useful to put a RDDL document at the end of an RDFS namespace; for improved understanding of RDF Schema terms.
20:46:48 [IanYVR]
DC: Suppose we have
as a namespace name.
20:46:57 [IanYVR]
DC: What would my browser show?
20:47:23 [IanYVR]
DC: How do I find RDF triple for subClassOf?
20:47:59 [IanYVR]
TBray: RDDL would point to a directory....
20:48:20 [IanYVR]
[DC draws RDDL document that links to another document with RDF assertions associated with subClassOf]
20:49:09 [IanYVR]
DC: Will the files (.rddl and .rdf) have the same names? I want to use content negotiation.
20:50:10 [IanYVR]
TBray: I think that in some cases you would want to use content negotiation (especially RDF case).
20:50:34 [IanYVR]
[Examine case where file names are different]
20:50:38 [IanYVR]
[I.e., conneg not used]
20:50:53 [IanYVR]
[Chris joins meeting]
20:51:53 [IanYVR]
TBray: So in this example, use nature"= "...rdf-syntax" and purpose = "formalDescription"
20:52:39 [IanYVR]
TBray: You could have another document in .n3, with nature="n3" and purpose="formalDescription"
20:52:47 [IanYVR]
DC: What is content type of .rddl document?
20:53:34 [IanYVR]
TBray: application/rddl+xml or application/xhtml+xml
20:54:03 [IanYVR]
TBray: Most (modern) browsers will handle application/xhtml+xml
20:54:11 [IanYVR]
DC: I get a "save as dialog".
20:54:19 [IanYVR]
TBray: Then you might have to serve as text/html...
20:54:44 [IanYVR]
DC: If we use "text/html" we have to put the HTML WG in the critical path and they'll say no.
20:56:06 [IanYVR]
[See xhtml 1.0 for guidelines on usage of text/html and application/xhtml+xml]
20:56:29 [IanYVR]
DC: I don't have any problem with rddl+xml.
20:57:29 [IanYVR]
DC: I think the RDDL spec needs at least a finding on content type.
20:57:39 [IanYVR]
[agreement]
20:59:04 [IanYVR]
TBray: The RDDL drafts come with a list of canonical natures and purposes
21:00:09 [IanYVR]
TBL: You should be able to get machine readable data without redirection (e.g., through conneg, by embedding RDF in RDDL, or by using RDF in place of RDDL).
21:00:19 [IanYVR]
DO: Another solution - put metadata in the URI...
21:00:40 [Norm]
q+
21:01:44 [IanYVR]
TBray: TBL can put RDF at end of namespace URI if he wants. I would argue with TBL but we have no business forbidding that.
21:02:13 [IanYVR]
NW: What is compelling reason for having RDF right off the bat?
21:02:23 [IanYVR]
TBL: If you can get data in time t, why take it in time t2?
21:02:27 [IanYVR]
DC: It works todya.
21:03:47 [IanYVR]
TBray: TBL's applications are untypical, in my opinion. The most common uses of namespaces is to compare namespace URIs as strings.
21:04:28 [IanYVR]
TBL: It is a core design item of the sem web to be able to get info with only one link, not an indirection.
21:04:41 [IanYVR]
TBray: In my opinion, benefits of indirection are so high you'll end up doing this anyway.
21:06:02 [IanYVR]
PC: Why write a finding if there's no preferred format?
21:06:23 [Norm]
q-
21:06:23 [IanYVR]
TBL: It's good to write a finding that says "It's good to put info at the end of a namespace URI."
21:07:39 [IanYVR]
CL: I don't see the point of a finding that doesn't make any recommendation about a format. Machines have no guarantee of what they'll finding.
21:07:57 [IanYVR]
DC: I think it's good to say "Here are some issues, they are approached different ways with different formats."
21:07:59 [Chris]
Chris has joined #tagmem
21:08:21 [IanYVR]
NW: I have found over last year that I would really like an indirection, and content negotiation is inadequate.
21:09:02 [IanYVR]
NW: It's a chicken and egg problem. APIs won't give indirection if there's no format out their they can know about.
21:09:21 [IanYVR]
NW: "May" use RDDL is good enough for me in a finding.
21:09:40 [IanYVR]
q?
21:11:08 [IanYVR]
Straw poll: (1) Finding says that namespace docs are useful, enumerates some issues, points to RDDL. (2) RDDL Note published.
21:11:54 [IanYVR]
TBray: And in the finding, say that RDF has been useful for RDF applications.
21:12:23 [IanYVR]
Comfortable with that: NW, DC, TBL, CL, TB
21:12:39 [IanYVR]
PC: I want the finding to say that whatever is there should be human readable. We don't seem to be discussing that particular point.
21:12:58 [IanYVR]
q+ TBL, DC
21:13:24 [IanYVR]
TBL: I think that we agree that it's useful to have something human readable. But in a sem web application, the machine readable information is primary.
21:13:25 [DaveO]
q+ DaveO
21:13:46 [IanYVR]
TBL: There are other ways to make the data human readable (e.g., through a style sheet). Don't say "human readable as opposed to machine readable".
21:13:49 [IanYVR]
ack TBL
21:13:53 [IanYVR]
q- DC
21:14:20 [IanYVR]
TBray: I think we can say that there are substantial advantages to human-readability; sem web applications can, for reasons of performance, do other things.
21:14:34 [IanYVR]
ack DanC_jam
21:14:34 [Zakim]
DanC_jam, you wanted to ask if folks find
human-readable
21:15:31 [IanYVR]
[Grumbling about level of human-readability of
]
21:15:52 [IanYVR]
DC: If there are serious concerns about this being-human readable, I claim that "human-readable" not meaningful as a temr.
21:15:55 [DanC_jam]
21:15:55 [IanYVR]
s/temr/term
21:15:58 [IanYVR]
ack DaveO
21:15:59 [DanC_jam]
try
21:16:42 [IanYVR]
DO: My recollection is the same as Paul's. The second that the Sem Web folks put machine-readable docs that aren't human-readable, the Web Services folks are likely to as well.
21:17:18 [IanYVR]
DO: I'd like the finding to say "SHOULD be human-readable" and MAY for RDDL.
21:18:13 [Stuart]
q?
21:18:38 [IanYVR]
DC: My point is that an RDF document can be human-readable when displayed with style sheets.
21:19:07 [IanYVR]
PC: I don't think there's a way to make an XML Schema human readable in a way that meets my test.
21:19:08 [IanYVR]
q?
21:19:17 [IanYVR]
CL: What's the test for human-readable?
21:19:21 [TimBL-YVR]
q+ to suggest a finding part saying taht machine-readable files can be made (more) human readable using various techniques.
21:19:48 [IanYVR]
PC: In many cases, a title at the top, "This doc defines the meanign of the namespace FOO. How it's used...what additional resources are available...purpose of namespace"
21:20:07 [IanYVR]
PC: Also include why someone might want to use the additional resources.
21:20:17 [TBray]
q+
21:20:53 [IanYVR]
NW: Human readable is important, but not the only important thing; indirection also important.
21:21:07 [Stuart]
ack timbl
21:21:07 [Zakim]
TimBL-YVR, you wanted to suggest a finding part saying taht machine-readable files can be made (more) human readable using various techniques.
21:21:36 [IanYVR]
TBL: I propose that we say that human readability is a good idea. When you are publishing something that is machine-readable, here are some techniques - use style sheets, embed human-readable information.
21:21:58 [Stuart]
ack tbray
21:22:13 [DanC_jam]
hmm... the RSS case is an interesting case in point.
21:22:29 [IanYVR]
TBray: I would be ok with a compromise: (1) You should achieve human-readability (2) RDDL is an option.
21:22:56 [IanYVR]
TBray: And here are some techniques for making information human readable.
21:24:16 [IanYVR]
PC: I'd rather point out conflict in a finding than hide it.
21:24:31 [TimBL-YVR]
q+ to posose hat rather than conflict, tis be considered as a richness.
21:24:38 [TimBL-YVR]
q+ DO
21:24:43 [DaveO]
q+
21:24:45 [DaveO]
q-
21:25:08 [ndw]
ndw has joined #tagmem
21:25:15 [IanYVR]
PC: I don't want to "hide behind a SHOULD"
21:25:36 [Chris]
should means 'must unless you have an excuse'
21:25:48 [IanYVR]
PC: I think the TAG needs to give clear reasons for why one wouldn't put something human-readable at end of namespace URI.
21:26:52 [IanYVR]
ack TimBL-YVR
21:26:52 [Zakim]
TimBL-YVR, you wanted to posose hat rather than conflict, tis be considered as a richness.
21:27:19 [IanYVR]
TBL: There is a spectrum of applications from very human-readable to very machine-readable.
21:27:38 [DaveO]
q- DO
21:27:51 [DaveO]
q+
21:28:10 [IanYVR]
PC: I think it would be useful to tell the community about the advantages of indirection.
21:29:18 [IanYVR]
PC: The finding should help new WGs avoid pitfalls by conveying benefits of human-readable, and indirection.
21:29:49 [DaveO]
Is this "Namespace document Best Practices?"
21:30:02 [IanYVR]
PC: If you have multiple schemas for the same thing, RDDL gives you advantages.
21:30:38 [IanYVR]
PC: If you only have one format and it's absolutely a characteristic of the application that performance is important, ok to use single format, but cost to losing human-readability and indirection.
21:31:00 [IanYVR]
PC: I want to avoid creating subgroups on the Web.
21:31:11 [TBray]
q=
21:31:15 [TBray]
Q+
21:33:13 [DaveO]
q?
21:33:18 [IanYVR]
ack DanC_jam
21:34:00 [IanYVR]
DC: I have an outline for a finding...
21:35:05 [DanC_jam]
outline:
21:36:12 [IanYVR]
ack DaveO
21:36:44 [IanYVR]
DO: I'm hearing PC argue for best practices on how to use namespace names. What kind of apps should dereference them.
21:38:41 [IanYVR]
[TB to summarize points for PC's finding]
21:38:50 [TBray]
Finding should say:
21:38:56 [TBray]
1. human-readability good
21:39:07 [TBray]
2. indirection good
21:39:20 [IanYVR]
3. Namespace doc good
21:39:44 [IanYVR]
PC: Usage scenario v. design scenario.
21:39:59 [TBray]
4. some risk in betting on some format being the One & Only Format
21:40:04 [IanYVR]
PC: There are advantages of indirectoin to have multiple different resources for human wnating to use the namespace.
21:40:42 [TimBL-YVR]
Point out the ability of RDDL to carry indirection.
21:40:59 [TimBL-YVR]
Point out the ability of RDF to contain arbitrary eg dublin core metadata.
21:41:29 [IanYVR]
TBL: Useful to have an example using RDDL and an example using RDF?
21:42:07 [IanYVR]
PC: I think the finding will give some examples of namespace docs.
21:42:30 [IanYVR]
TBray: For the Note, I've agreed to put some examples in, to include xslt script in appendix.
21:42:37 [IanYVR]
TBray: And say a few words on content type.
21:42:54 [IanYVR]
NW: You need to inline natures and purposes (i.e., put the list in the spec)
21:43:15 [IanYVR]
DC: Put some examples showing their usage.
21:43:31 [IanYVR]
NW: One of the natures should be "RDDL Document" (forward versioning)
21:43:48 [IanYVR]
q?
21:43:56 [IanYVR]
q- TBray
21:45:02 [IanYVR]
PC: I think that reasons for publishing Note have slipped by.
21:45:12 [IanYVR]
PC: There might be other technical issues, we might want to register content type.
21:45:28 [IanYVR]
TBray: I think if we publish Note we've done our job.
21:45:51 [IanYVR]
PC: We should also send email to the AC explaining our position.
21:46:24 [TimBL-YVR]
q?
21:46:26 [IanYVR]
IJ: I heard from AC meeting "Publish as Note first, then we'll figure out what to do."
21:47:26 [DanC_jam]
(did the minutes include tbray's RDDL todo? at the risk of redundancy: A: examples. B: XHTML DTD minutiae C: XSLT to convert to RDF, D: media type)
21:47:26 [IanYVR]
Action items for TB (RDDL Note) and PC (issue 8 finding) continued.
21:47:47 [Chris]
propose that we hold the 15:00 to 15:30 break now, ie 14:45 to 15:00
21:47:59 [Chris]
thus gaining 30 minutes for the next slot
21:48:14 [IanYVR]
DC: I'm happy to contribute text to PC's finding on content negotiation.
21:48:26 [IanYVR]
[Break]
22:12:30 [Chris]
</break>
22:13:00 [TimBL-YVR]
__________________________
22:13:06 [IanYVR]
Findings in progress
22:13:07 [TimBL-YVR]
metadata in URI
22:13:19 [IanYVR]
Draft finding from SW:
22:13:31 [IanYVR]
SW: Is "don't peek inside" enough advice?
22:13:44 [TBray]
q+
22:13:51 [IanYVR]
SW: Questions about what one can infer from different pieces of a URI (e.g., resource nature from scheme registration)
22:15:45 [IanYVR]
SW: A number of perspectives: origin server (assignment authority) v. infrastructure (e.g., caches, libwww), v. applications
22:16:41 [Chris]
q?
22:16:45 [DanC_jam]
ack danc
22:16:45 [Zakim]
DanC_jam, you wanted to suggest thanking for bray and cotton for taking their respective actions and break.
22:16:54 [IanYVR]
ack TBray
22:17:11 [IanYVR]
TBray: I think happy medium between minimal approach (DC) and SW's current finding.
22:17:58 [IanYVR]
[Roy joins meeting]
22:18:42 [IanYVR]
1) When you are processing a URI, there are normative specs (starting with [URI], then scheme specs); it's fine to peek inside URIs and interpret per normative specs.
22:19:01 [IanYVR]
2) Beyond that it's inappropriate to make other assumptions by peeking in URI UNLESS you have private agreements.
22:19:14 [IanYVR]
(i.e., rules published by the URI authority)
22:19:17 [DaveO]
q+
22:20:12 [TBray]
q+
22:20:16 [IanYVR]
ack DaveO
22:20:39 [TimBL-YVR]
q+ to ask for a summary of any substantial points made on the thread not compatible with the finding as is.
22:20:53 [IanYVR]
DO: I think that we need to describe when it's ok to peek inside a URI. And when it's ok to write a spec that says it's ok to peek inside a URI.
22:21:07 [IanYVR]
DO: I had an action item to talk to WSDL folks about why they want to peek inside their URIs.
22:21:30 [IanYVR]
DO: They have created a number of symbol spaces. Names are not unique across symbol spaces. They want to use the symbol space to differentiate items.
22:21:36 [IanYVR]
DO: (Issue 37)
22:21:55 [IanYVR]
DO: They want to have metadata in a well-defined format so that software can have predictability for how to process URIs in WSDL docs.
22:22:07 [IanYVR]
DO: So the WSDL spec would be a normative spec for how to interpret the URIs in WSDL docs.
22:22:24 [TimBL-YVR]
q+ to aska determining question of DO as to whther a non-WSDL-sware agent could be able to determine what is denote dby one of these URIs in the WSDL URIs.
22:22:29 [IanYVR]
DO: I think that there is at least one group that believes that an example of a "normative" spec is the WSDL spec.
22:22:35 [IanYVR]
q+ Stuart
22:22:37 [TimBL-YVR]
q+ Stewart
22:22:51 [DanC_jam]
ack danc
22:22:51 [Zakim]
DanC_jam, you wanted to ask how what bray is saying is different from what's written and to ask for an example of one of these WSDL non-opaque URIs
22:22:52 [IanYVR]
ack DanC_jam
22:22:54 [TimBL-YVR]
oops
22:23:10 [IanYVR]
DC to TB: How is what you said different from SW's draft finding?
22:23:54 [IanYVR]
TBray: I think draft finding is too long, but I'm prepared to accept the assertion that SW's finding says what I mean.
22:24:17 [IanYVR]
TBray: Do people agree that it's ok for the WSDL folks to say how to interpret their URIs?
22:24:48 [DanC_jam]
somebody help me find the examples DO is talking about from
22:24:56 [TBray]
q+ Stuart
22:25:06 [TBray]
ack TBray
22:25:12 [TBray]
ack TimBL-YVR
22:25:12 [Zakim]
TimBL-YVR, you wanted to ask for a summary of any substantial points made on the thread not compatible with the finding as is. and to aska determining question of DO as to whther a
22:25:15 [Zakim]
... non-WSDL-sware agent could be able to determine what is denote dby one of these URIs in the WSDL URIs.
22:25:17 [IanYVR]
TBL: I have a criterion for this: suppose that someone has not come across the WSDL spec. Given a URI that was constructed according to the WSDL rules, can someone with such a URI (alone) determine that it's a WSDL URI?
22:26:12 [IanYVR]
TBL: E.g., do they get back a description (e.g., in a representation) of how to use the URI?
22:26:12 [DanC_jam]
ah... summary
22:27:16 [IanYVR]
DO: Part of issue 37 is to use the namespace name and frag id syntax that uses symbol space metadata. "Clever" use of frag ids.
22:27:39 [IanYVR]
DO: The domain authority can do what they want when they construct the URI. Then, the restrictions about the frag id kick in.
22:27:59 [TimBL-YVR]
DO: They plan to use a namesapce name with has a particular fradid syntax.
22:27:59 [TBray]
q+ to suggest that Section 1 of Stuart's draft could stand alone and solve the problem
22:28:14 [IanYVR]
ack Stuart
22:28:21 [TimBL-YVR]
q+ to say that if you want a funny fragid syntax you need a new mime type
22:29:40 [DanC_jam]
new summary 19Jun
22:30:01 [DanC_jam]
[[
22:30:03 [DanC_jam]
The sample URI is
22:30:03 [DanC_jam]
"(TicketAgent/listFlights/listFlightsR
22:30:03 [DanC_jam]
equest)".
22:30:04 [DanC_jam]
]]
22:30:06 [ndw]
ndw has joined #tagmem
22:30:37 [DanC_jam]
ack tbray
22:30:37 [Zakim]
TBray, you wanted to suggest that Section 1 of Stuart's draft could stand alone and solve the problem
22:30:44 [IanYVR]
TB Proposal: Section 1 of Stuart's draft could stand alone and solve the problem
22:31:34 [Chris]
q+ ndw
22:31:40 [DanC_jam]
I think I agree with bray that replacing the finding by its 1st section would be forward progress
22:31:53 [IanYVR]
NW: You can't say squat about meaning of frag ids until you get the representation with the proper content type.
22:32:29 [IanYVR]
TBL: I'm fine to talk about an imaginary document. But if you do retrieve it, you need to register a new content type or a frag id syntax.
22:32:45 [DanC_jam]
ack timbl
22:32:45 [Zakim]
TimBL-YVR, you wanted to say that if you want a funny fragid syntax you need a new mime type
22:32:46 [IanYVR]
DO: WSDL WG wants to register a new content type.
22:32:48 [Stuart]
re: specs defining patterns for using structure in URI assignments to name abstract things, how do you establish a chain to establish authority to make such an assignment? 2396 delegates assignment authority to URI schemes which in turn delegate onwards ultimately to some spec. or person or organisation. Such an authority could then explicitly state that they do infact make assignments according to the spec'd. pattern.
22:33:27 [DaveO]
q+
22:33:29 [IanYVR]
DC: I second TB's proposal.
22:33:42 [IanYVR]
SW: There was feedback on the list that the parts after section 1 were useful.
22:34:02 [TimBL-YVR]
q?
22:34:10 [IanYVR]
TBray: In an ideal world, I would leave section 1 and provide a bunch of examples.
22:34:11 [DanC_jam]
ack ndw
22:34:12 [IanYVR]
ack ndw
22:34:15 [TimBL-YVR]
q+ for examples
22:34:16 [IanYVR]
ack DaveO
22:34:44 [TimBL-YVR]
q+ to examples
22:34:55 [TimBL-YVR]
q- for examples
22:35:06 [IanYVR]
DO: I agree with section 1 with examples, including an example for what format spec designers can do. Also, what format spec designers should do about path components.
22:35:15 [IanYVR]
NW: I.e., using "/" instead of "#".
22:35:33 [IanYVR]
DC: I'm happy with DO's proposal.
22:36:52 [TBray]
q+
22:36:57 [Stuart]
q+ Chris
22:37:19 [IanYVR]
RF: If a scheme does not provide for authoritative metadata, then it is normal to use the URI to get more information about what you might get back.
22:37:26 [TimBL-YVR]
q+ to ask Stuart to add a a mention that fragid needs mime type in 3.4
22:37:30 [IanYVR]
CL: If this is about HTTP only, we should say that.
22:37:42 [IanYVR]
CL: If about more schemes, we need to talk about RF's issue.
22:38:02 [IanYVR]
TBray: I think that the text as written is correct since it says that you can do what the spec authorizes you to do.
22:38:11 [DaveO]
q+
22:38:40 [IanYVR]
TBray: So, for FTP, you can use path components for directory navigation.
22:38:41 [DanC_jam]
tim, why not consider ftp?
22:39:00 [DanC_jam]
ftp is how a significant part of the web is written
22:39:14 [IanYVR]
RF: I don't think we should make the finding specific to a URI scheme. Give an example of a relative normative spec that is providing policies for looking within the URI.
22:39:28 [IanYVR]
TBray: HTTP is distinguished in that other than the "/" there is no info you can use.
22:39:29 [Stuart]
q?
22:39:43 [IanYVR]
ack TimBL-YVR
22:39:43 [Zakim]
TimBL-YVR, you wanted to examples and to ask Stuart to add a a mention that fragid needs mime type in 3.4
22:39:43 [DanC_jam]
ack TimBL-YVR
22:39:44 [TimBL-YVR]
ack tim
22:39:57 [TBray]
ack TBray
22:40:16 [Chris]
ack chris
22:40:31 [Roy]
Roy has joined #tagmem
22:41:21 [IanYVR]
RF: Section 1.1, part one - We need an example.
22:42:25 [IanYVR]
TBL: 2.2 and ff should be under 3 (stuff about HTTP)
22:42:52 [IanYVR]
TBL: "And if it's HTTP...."
22:43:06 [IanYVR]
SW: I'd prefer to not go into a particular scheme.
22:43:38 [IanYVR]
SW: For me, section 2 was about client perspective and section 3 was from perspective of assignment authority.
22:43:54 [IanYVR]
SW: I could merge the two and do each component from both perspectivies.
22:44:28 [IanYVR]
TBL: You need to say that the authority can never get to a server manager unless you have gone through a spec.
22:44:48 [IanYVR]
TBL: And you need to use registration mechanisms (e.g., for new frag id semantics).
22:44:55 [DaveO]
q?
22:45:14 [IanYVR]
ack DaveO
22:45:52 [Chris]
q+ to worry about implying that inferring anything from scheme is also bad, which it isn't
22:45:58 [IanYVR]
DO: I think 37 depends on SW's finding.
22:46:33 [IanYVR]
[Veering into issue 37]
22:46:47 [IanYVR]
DO: One proposal is for metadata in path component v. fragment identifier.
22:47:52 [IanYVR]
RF: Not just putting metadata in the path. It's metadata that's to be interpreted by the client while inspecting the URI.
22:48:07 [IanYVR]
q+
22:48:14 [DanC_jam]
ack danc
22:48:14 [Zakim]
DanC_jam, you wanted to ask that forms be one of the examples (perhaps redundant: other examples I agree would be good: making a new mime type that says how #blort works, and path
22:48:17 [Zakim]
... components)
22:48:56 [Chris]
old bad html forms?
22:49:09 [DanC_jam]
html forms are bad?
22:49:13 [IanYVR]
DC: And mime types say how mime types work.
22:49:19 [IanYVR]
ack Chris
22:49:19 [Zakim]
Chris, you wanted to worry about implying that inferring anything from scheme is also bad, which it isn't
22:49:21 [Chris]
hence their redisign, clearly
22:49:52 [DaveO]
Question: Can spec designers constrain the format of URIs to contain metadata in the path component of a URI?
22:50:35 [TimBL-YVR]
Yes lets discuss 0054.html . I disagree with 6 but agree with the rest.
22:51:07 [IanYVR]
SW: Question of whether
mailto:
URIs can only be used to refer to mailbox addresses.
22:51:15 [DaveO]
q+
22:51:20 [IanYVR]
ack IanYVR
22:51:21 [TimBL-YVR]
Answer: No they should not
22:51:47 [IanYVR]
IJ: It seems to me that a single finding might cover both issues.
22:51:52 [IanYVR]
SW: That might be an outcome.
22:51:54 [IanYVR]
ack DaveO
22:52:17 [IanYVR]
DO: RF suggested that WSDL WG not use frag ids for metadata. RF suggested alternatives in the path component.
22:52:26 [IanYVR]
DO: Or use of ";"
22:52:42 [IanYVR]
RF: Traditionally identifiers are orthogonal to media type definitions.
22:53:37 [IanYVR]
RF: Putting metadata in URI puts a tie between how URI is constructed and how media type is constructed.
22:53:49 [IanYVR]
RF: It's worse to do this for the path component than for the frag id component.
22:54:21 [IanYVR]
22:54:31 [IanYVR]
10. Use a URI convention that slashes separate namespace URI and component
22:54:31 [IanYVR]
identifier. Posted by Roy at [11]
22:54:45 [IanYVR]
22:55:10 [TimBL-YVR]
q+ to say that you don't mess with th e URI space because if one lot contarin it then everyone else does and thy clash.
22:56:34 [IanYVR]
RF: The reason I included this option:
22:56:39 [IanYVR]
";
22:56:39 [IanYVR]
input"
22:56:51 [IanYVR]
RF: It's associated with same level of hierarchy.
22:57:21 [Stuart]
q?
22:57:56 [IanYVR]
DO: When using frag id solution, problem of inconsistent frag id semantics across different representation media types.
22:58:54 [IanYVR]
DO: As part of issue 31, we need to say something in conjunction with issue 8. If you want to put your own semantics into frag id, you can't use RDDL or conneg.
22:59:06 [IanYVR]
DO: If people want to use RDDL, they can't put metadata in their own frag id syntax.
22:59:10 [IanYVR]
ack TimBL-YVR
22:59:10 [Zakim]
TimBL-YVR, you wanted to say that you don't mess with th e URI space because if one lot contarin it then everyone else does and thy clash.
22:59:14 [Roy]
q+
22:59:29 [IanYVR]
TBL: The primary req is that you can do the right thing when you dereference the URI.
22:59:36 [IanYVR]
TBL: I think that making the identifiers unique is reasonable.
23:00:32 [IanYVR]
TBL: I think that there other ways to ensure uniqueness other than by prepending class description, however.
23:01:13 [IanYVR]
TBL: The reason that you don't establish conventions for how to interpret the last few pieces of the path is that you lose if anybody else defines semantics for the same components.
23:01:30 [IanYVR]
TBL: This part of the URI is not your space. This is server manager space.
23:01:51 [IanYVR]
TBL: You can't control what people do with URIs. The architecture is that this is internal to the server.
23:01:52 [DanC_jam]
ack danc
23:01:52 [Zakim]
DanC_jam, you wanted to ask how an arbitrary party "groks" this example URI
23:02:34 [TBray]
q+
23:02:35 [IanYVR]
DC to DO: Do you have questions about the solution with the hash in it?
23:03:18 [IanYVR]
DC: Earlier TBL asked how an arbitrary party figures out that a URI is governed by the WSDL spec. I'd like to walk through that.l
23:04:08 [IanYVR]
Example URI: "
"
23:04:11 [TimBL-YVR]
The server writer and the server administrator own teh URI space on a server. As WSDL spec writer, you can't put constraints on that space, or there will be horrible clashes. The URIs on web servers are generated from exposed foreign systems, databases, etc.
23:04:27 [IanYVR]
DO: One of the issues is that, without a frag id, you don't know where the end of the namespace is.
23:04:59 [IanYVR]
DO: If you use this syntax, you can't get back to WSDL spec.
23:05:22 [IanYVR]
NW: You can dereference the URI.
23:05:46 [IanYVR]
NW: Send back the WSDL document.
23:06:11 [IanYVR]
NW: You can't tell what the URI means without the deref; but that's the same issue with the frag id solution.
23:06:13 [DanC_jam]
ack roy
23:06:22 [DaveO]
I was wrong, Norm's right..
23:06:37 [IanYVR]
RF: It's also fair do assume that if RDDL is going to be used as a descriptive text, that it's capable of defining an arbitrary number of frag names in the description.
23:07:41 [DanC_jam]
(if you continue that line of thought, you'll end up with RDF)
23:07:53 [IanYVR]
TBray: If you are putting metadata in a URI, it's at least questionable; this gets in the way of server administration.
23:08:10 [IanYVR]
DO: See option 9 for put semantics in RDDL frag ids.
23:08:40 [IanYVR]
TBray: Seems to me that the WSDL folks are pushing up against limits of what's comfortable to do with URIs.
23:08:51 [TimBL-YVR]
q+ to suggest the customer is right
23:09:23 [Stuart]
q?
23:09:45 [IanYVR]
TBray: One could, for the RDDL media type, allowing redirection of a piece of a frag id to be interpreted according to the media type of the related resource.
23:09:49 [IanYVR]
DO: That's option 9.
23:09:51 [ndw]
ndw has joined #tagmem
23:09:59 [DanC_jam]
ack tbray
23:10:18 [IanYVR]
q+ Norm
23:10:23 [IanYVR]
q+ me
23:10:27 [IanYVR]
ack Norm
23:11:06 [DanC_jam]
ack timbl
23:11:07 [Zakim]
TimBL-YVR, you wanted to suggest the customer is right
23:11:29 [ndwalsh]
ndwalsh has joined #tagmem
23:11:50 [IanYVR]
TBL: What the WSDL folks want to do is a variant of what the RDF folks have done.
23:11:57 [IanYVR]
TBL: And it's reasonable.
23:12:52 [IanYVR]
TBL: The point is that if you find one of these URIs in space, you need to be able to find the link back to the defining spec.
23:12:57 [DanC_jam]
ack ian
23:12:59 [Stuart]
Q?
23:13:06 [DanC_jam]
ack danc
23:13:06 [Zakim]
DanC_jam, you wanted to say that the WSDL folks are trying to give URIs to important resources
23:13:11 [TimBL-YVR]
RDF does this quite successfully.
23:13:33 [IanYVR]
DC: Bray observes that "it hurts when they do this"; I don't think we should tell them not to do this - we told them to give URIs to important resources.
23:13:53 [Stuart]
Q?
23:15:04 [IanYVR]
NW: How does it help if the WSDL document is an RDF?
23:15:56 [IanYVR]
RF: RDF has not invented any of this stuff....
23:15:59 [Chris]
nw: rdf fails the same way this fails - no idea what the fragment means until you retrieve the resource
23:16:21 [DaveO]
q+
23:16:35 [IanYVR]
ack DaveO
23:16:51 [TimBL-YVR]
q+ to propose we recommend [3]
23:16:57 [TBray]
23:17:20 [Roy]
q+
23:17:22 [IanYVR]
DO: For RDDL, we should look at this question of indirection, and how to include metadata in URIs that can be forwarded through RDDL.
23:17:26 [Stuart]
q?
23:17:40 [IanYVR]
PC: In v1?
23:17:44 [IanYVR]
TBray: Yes. I think it would be useful.
23:17:47 [IanYVR]
ack TimBL-YVR
23:17:47 [Zakim]
TimBL-YVR, you wanted to propose we recommend [3]
23:17:47 [DanC_jam]
ack timb
23:17:49 [TimBL-YVR]
ack tim
23:18:22 [IanYVR]
TBL: The RDDL solution doesn't work with RDF. Anyone who uses RDDL has to put a wrapper around their frag id.
23:18:34 [Chris](TicketAgent/listFlights/listFlightsR
23:18:38 [Chris]
oops
23:18:56 [IanYVR]
RF: If RDDL treats all frag ids as opaque strings....
23:19:10 [Chris]
23:19:14 [Chris]
equest
23:19:25 [Chris]
look no parens
23:19:40 [IanYVR]
TBL: Suppose RDDL doc points to three alternative formats, you need to know format of related resource to interpret frag id semantics.
23:19:44 [Stuart]
q?
23:19:49 [Stuart]
ack Roy
23:20:07 [IanYVR]
RF: Use flat namespaces.
23:20:23 [Stuart]
q+ DanC
23:21:00 [IanYVR]
ack DanC
23:21:02 [ndw]
q+
23:21:07 [IanYVR]
ack DanC_jam
23:21:07 [Zakim]
DanC_jam, you wanted to suggest RDDL has union links
23:22:03 [IanYVR]
DC: I claim that RDF solves these problems. But if you want to have RDDL doc in between - if you want to interpret the frag id w.r.t. a RDDL document, you are saying you can use a fragment in any of the alternative related resources.
23:22:24 [Stuart]
q?
23:22:43 [IanYVR]
TBL: This is only for the case of "ids".
23:23:16 [IanYVR]
ack ndw
23:23:18 [TimBL-YVR]
RDDL = Poor Man's Content Negotiation
23:23:35 [DaveO]
WSDL proposal does NOT use "ids".
23:24:08 [DaveO]
q+
23:24:46 [Stuart]
q+ Chris
23:25:02 [Chris]
q+ to wish fragment identifiers identified fragments not 'you get to rewrite any spec'
23:25:04 [DanC_jam]
ack daveo
23:25:09 [IanYVR]
TBray: Could write RDDL spec to say that you can't interpret RDDL instance until you've
23:25:13 [IanYVR]
retrieved related resources
23:25:40 [DanC_jam]
using RDDL as the content of the HTTP 4xxx "multiple choices" would be pretty ideal.
23:25:42 [TBray]
can't interpret RDDL #fragment IDs against rDDL itself, but agaisnt a related resource
23:25:43 [Chris]
deferred fragment attachment on indirection
23:26:07 [Chris]
so, can never point to a part of a rddl document, in consequence
23:26:23 [IanYVR]
TBray: The price of this is that you lose the ability to point to a thing inside the RDDL document itself.
23:26:28 [IanYVR]
q+ Roy
23:26:32 [DanC_jam]
ack chris
23:26:32 [Zakim]
Chris, you wanted to wish fragment identifiers identified fragments not 'you get to rewrite any spec'
23:27:30 [IanYVR]
TBray: When you register a media type you should specify the frag id semantics. It's perfectly ok to specify the semantics to be "This frag id doesn't apply to me; it applies to a related resource representation."
23:27:45 [DanC_jam]
(this conflict between pointing at parts of XML documents and pointing at 'abstract components' is well known in RDF-land, fyi... it's related to our RDF in XHTML issue, and our fragments in XML issues)
23:27:49 [IanYVR]
ack Roy
23:28:10 [TBray]
q+
23:28:18 [IanYVR]
RF:Unless you use xpointer, I don't see any reason why the syntax wouldn't be identical for the WSDL document as it would be for the RDDL document.
23:28:50 [TBray]
q+ to say that you can to point into a RDDL document just fine
23:28:51 [IanYVR]
RF: E.g., if you use a dot-separated list of names as WSDL frag id syntax, there's no reason why that syntax and the RDDL syntax couldn't be consistent.
23:29:42 [Stuart]
q?
23:29:57 [Stuart]
ack TBray
23:29:57 [Zakim]
TBray, you wanted to say that you can to point into a RDDL document just fine
23:30:30 [TimBL-YVR]
q+ to propose [3]
23:31:27 [IanYVR]
[Examining options of issue 37]
23:31:44 [IanYVR]
23:31:56 [IanYVR]
DO: Let's look at requiremens.
23:32:06 [IanYVR]
1. It must be possible to identify each conceptual element in a WSDL
23:32:06 [IanYVR]
vocabulary with a URI.
23:32:12 [IanYVR]
2. It should be simple to create and use the URI
23:32:16 [IanYVR]
3. It must be compliant with the URI specification.
23:32:23 [IanYVR]
4. It should be able to identify WSDL extensions, ala soap:binding,
23:32:23 [IanYVR]
soap:operation, soap:address, soap:body, soap:action, soap:fault,
23:32:24 [IanYVR]
soap:header, soap:headerfault, http:address, http:binding, http:urlEncoded,
23:32:24 [IanYVR]
http:urlReplacement, mime:content, etc.
23:32:35 [IanYVR]
5. It should be possible to use relative URIs for the abstract components
23:32:45 [IanYVR]
6. It should be possible to extract the type information from the URI.
23:32:56 [IanYVR]
7. It should be possible to retrieve a namespace name document given an
23:32:56 [IanYVR]
astract component reference.
23:38:39 [IanYVR]
DC: I don't buy all of the requirements.
23:38:41 [Chris]
comment on requirement 6:
23:38:43 [Chris]
23:39:07 [IanYVR]
DC, TBL: I don't agree with 6.
23:39:15 [Chris]
I can extract a type (dateTime) from that URI or rather, I can use that URI to identify dateTime type
23:39:16 [IanYVR]
TBL: Req 6 is architecturally harmful.
23:39:42 [Stuart]
q+ Chris
23:39:54 [Stuart]
ack TimBL
23:39:54 [Zakim]
TimBL-YVR, you wanted to propose [3]
23:40:09 [Stuart]
ack Dan
23:40:09 [Zakim]
DanC_jam, you wanted to note that issue 37 is now barely distinguishable from issue
23:40:15 [DanC_jam]
hey!
23:40:23 [DanC_jam]
I haven't gotten the floor
23:40:24 [IanYVR]
CL: People who define URIs can put whatever metadata they want in the URI.
23:40:35 [Stuart]
apologies
23:41:12 [Roy]
q+
23:41:24 [Roy]
ack Chris
23:41:41 [DanC_jam]
ack danc
23:41:41 [Zakim]
DanC_jam, you wanted to note that issue 37 is now barely distinguishable from issue
23:42:07 [IanYVR]
DC: Issue 28 related - do frag ids refer to syntactic element or can they refer to abstractions?
23:42:32 [IanYVR]
DO: Issue 37 proposes a particular interpretation for issue 28. But if we recommend another solution for 37, it's not related (i.e., frag ids not used).
23:42:36 [Stuart]
ack Roy
23:42:50 [ndwalsh]
ndwalsh has joined #tagmem
23:43:04 [IanYVR]
RF: For req 5 - does "relative URI" mean relative to the namespace URI or unrestricted relative URIs?
23:43:22 [IanYVR]
RF: Only way you'll get unrestricted is if you don't use frag id syntax solution.
23:44:27 [IanYVR]
TBray: What are the identifiers used for in practice?
23:44:32 [Stuart]
q?
23:44:39 [IanYVR]
DO: E.g., identification of input when building tooling.
23:44:41 [Roy]
q+
23:44:52 [IanYVR]
DO: They might have a lookup to see what the name is.
23:45:10 [IanYVR]
DO: There's talk about, on the wire, specifying what an action is in a SOAP header and mapping that to the input.
23:45:30 [IanYVR]
TBray: Sounds like they want to do what URNs are designed to do.
23:46:15 [Stuart]
ack Danc
23:46:15 [Zakim]
DanC_jam, you wanted to ask that the record show that we has some comments and questions on requirement 5, 6, and 7, but that said, let's look at solutions in any order dave
23:46:18 [Zakim]
... chooses
23:46:21 [IanYVR]
DC: We've discussed the reqs to my satisfaction.
23:46:29 [Stuart]
ack Roy
23:47:30 [Roy]
q+
23:47:37 [IanYVR]
NW, SW, TB: I can live with option 1.
23:47:56 [DanC_jam]
(paste pointer to list again, pls?)
23:48:05 [IanYVR]
23:49:19 [DanC_jam]
(we're talking about #2 now?)
23:49:31 [IanYVR]
DO: Sometimes WSDL docs are modularized; hard to constrain uniqueness constraint across WSDL docs.
23:49:42 [IanYVR]
TBL, NW, DC, CL, TB: Can live with option 2
23:49:56 [IanYVR]
RF: I could live with it as well, but I don't think it's a realistic solution.
23:50:06 [IanYVR]
RF: Too many names.
23:50:15 [IanYVR]
PC: That's why I didn't put up my hand.
23:50:37 [IanYVR]
RF: Lots of human error possible in generation in individual names.
23:50:45 [IanYVR]
[option 3]
23:50:57 [IanYVR]
Require Unique NCNames.
23:51:05 [IanYVR]
DO: You combine the symbol spaces into one.
23:51:33 [IanYVR]
DO: You combine the symbol spaces into a single space, within a particular WSDL document.
23:52:08 [IanYVR]
TBray: This is identical to choosing an id.
23:52:17 [IanYVR]
TBray: 3 is a flavor of 2
23:52:40 [IanYVR]
Option 4
23:52:43 [IanYVR]
Use XPointer
23:52:54 [DanC_jam]
(perhaps ask who prefers this option when asking who could live with it)
23:53:21 [IanYVR]
DO: I think this uses xpointer framework and element scheme.
23:53:38 [IanYVR]
{Nobody likes}
23:53:46 [IanYVR]
[Option 5]
23:53:54 [IanYVR]
Use element(), XPointer framework
23:54:11 [IanYVR]
CL: Problems with this option are fixable.
23:54:15 [IanYVR]
{But no strong support}
23:54:22 [IanYVR]
[Option 6]
23:54:28 [IanYVR]
Develop WSD specific Xpointer scheme
23:54:37 [IanYVR]
NW, CL: Can live with option 6
23:54:47 [IanYVR]
[Option 7]
23:55:00 [IanYVR]
Schema component designators
23:55:08 [IanYVR]
CL: Less ugly than 4!
23:55:22 [TBray]
Record to show that ones I don't vote for in some cases because I just don't understand
23:55:43 [IanYVR]
DC: Inasmuch as option 7 is not good for WSDL, I don't think that it's good for schema either.
23:56:07 [IanYVR]
PC: Schema's task is to define global and local things; different from WSDL task (global only)
23:56:25 [IanYVR]
NW, CL: Could live with 7
23:56:34 [Roy]
q?
23:56:57 [IanYVR]
ack Roy
23:57:48 [IanYVR]
RF: Earlier I was going to say that info isn't metadata if it's necessary to identify the resource in question.
23:57:56 [IanYVR]
[option 8]
23:58:06 [DanC_jam]
(what Roy mentioned about 'not metadata' is the restrictive vs. non-restrictive clauses, as we discussed, Ian)
23:58:07 [IanYVR]
8. Use namespace name and new fragment identifier syntax. This is the
23:58:07 [IanYVR]
current WSD proposal.
00:00:22 [IanYVR]
ack DanC
00:00:53 [Stuart]
q+
00:01:01 [IanYVR]
DC: I think that there's a risk, but not a violation. If you fetch the thing and get WSDL, you can get authoritative info. If you don't fetch it you take the risk that you're wrong.
00:01:22 [IanYVR]
DC: But someone else could have told you that the doc you get back is WSDL...
00:02:03 [IanYVR]
ack Chris
00:02:36 [IanYVR]
CL: What about ".....#/.../..."
00:02:43 [Stuart]
q-
00:03:04 [IanYVR]
DO: So that after "# and before first "/" is symbol space.
00:03:40 [IanYVR]
CL: I believe it's much clearer to use functional notation, and there might be text after the end of the closing paren.
00:03:58 [IanYVR]
ack TBray
00:04:10 [IanYVR]
TBray: I find option 8 unpalatable.
00:04:27 [TimBL-YVR]
q+ to ask about qnames
00:04:40 [IanYVR]
TBray: RFC2396bis still says that the format and resolution of frag ids depends on media type.
00:05:15 [IanYVR]
TBray: Option 8 is at odds with this.
00:05:37 [IanYVR]
DC: If the guy doesn't fetch the resource, it's not that RFC2396bis has been violated, but person who has dereferenced is taking a risk.
00:07:32 [IanYVR]
DO: If one follows option 8, it will lead people to put WSDL docs at end of their namespace URIs, and if they don't they incur risk that frag ids will not make sense.
00:08:56 [DaveO]
q+
00:09:15 [IanYVR]
RF: This is a restricted application; you're not going to ever want anything other than a WSDL document.
00:11:56 [IanYVR]
[To be continued...]
00:11:59 [IanYVR]
q=
00:12:01 [DanC_jam]
(we didn't just adjourn?)
00:12:04 [IanYVR]
q-
00:12:05 [IanYVR]
q-
00:12:09 [IanYVR]
q=""
00:12:12 [IanYVR]
q- ""
00:12:43 [TimBL-YVR]
625 W22nd
00:13:17 [DanC_jam]
(did we resolve to begin at 8am tomorrow?)
00:13:24 [IanYVR]
[DO, PC]
00:13:47 [Chris]
00:14:27 [IanYVR]
"Separation of semantic and presentational markup, to the extent possible, is architecturally sound"
00:14:29 [ndwalsh]
ndwalsh has joined #tagmem
00:14:34 [DanC_jam]
no story?
00:15:10 [DanC_jam]
hmm... making up words... restylability
00:15:25 [IanYVR]
DC: The story should raise the issue.
00:16:00 [IanYVR]
Accessibility offers lots of good stories of why good to separate content and presentaiton
00:16:01 [TimBL-YVR]
51 muddles level of abstraction and level of detail
00:16:16 [TimBL-YVR]
5.1
00:17:50 [IanYVR]
q+ to say that the strongest resistance he's encountered when telling authors to design flexible content is that they don't like styling other than their original intention. They don't want users to override their intention, for example, even if content goes from unusable to usable.
00:18:18 [DanC_jam]
yes, figures please
00:19:21 [DanC_jam]
yes, well, Ian, I think it's useful for the TAG to let those authors know that they're fighting the medium. There's a time and a place for that, but we can and should be clear that it's not usually good.
00:19:34 [IanYVR]
I understand that.
00:20:00 [IanYVR]
I note that what CL is covered by the XML Accessibility Guidelines
00:20:09 [IanYVR]
s/what CL/what CL has said/
00:20:48 [IanYVR]
IJ: There are costs of separation - packing.
00:20:54 [IanYVR]
s/packing/packaging necessary
00:21:06 [IanYVR]
Sure that's a cost!
00:21:22 [IanYVR]
If I give you one file, that's easier to view than if there are 3 files to use a spec.
00:21:31 [IanYVR]
URIs are good, but we
00:21:46 [IanYVR]
do have to deal with people doing things offline.
00:22:13 [IanYVR]
XML Accessibility Guidelines:
00:22:25 [IanYVR]
Guideline 2. Create semantically-rich languages
00:22:31 [IanYVR]
2.2 Separate presentation properties using stylesheet technology/styling mechanisms.
00:22:55 [IanYVR]
2.11 Specific checkpoint for Final-form applications.
00:24:56 [IanYVR]
TBL: Sometimes you want to limit the amount of reusability.
00:25:20 [Roy]
q?
00:25:21 [IanYVR]
TBL: Distinguish level of abstraction and level of detail.
00:25:30 [Roy]
q+
00:25:37 [IanYVR]
q- IanYVR
00:32:04 [DanC_jam]
ack danc
00:32:04 [Zakim]
DanC_jam, you wanted to note the 'possible' in the title
00:32:31 [IanYVR]
I suggest "On the separation of semantic and presentation"
00:32:38 [IanYVR]
I suggest "On the separation of semantics and presentation"
00:33:36 [IanYVR]
[Discussion of length of finding...]
00:33:52 [IanYVR]
CL: For the moment it's exploratory...
00:34:02 [IanYVR]
ack Roy
00:34:41 [IanYVR]
RF: Change "abstract" to "detail".
00:34:50 [IanYVR]
RF: Or talk about granularity.
00:35:02 [IanYVR]
RF: Don't say "abstract"
00:35:12 [IanYVR]
DC: For me "abstract" worked.
00:35:44 [IanYVR]
ADJOURNED
00:35:50 [IanYVR]
RRSAgent, stop | http://www.w3.org/2003/07/21-tagmem-irc.html | crawl-001 | en | refinedweb |
The generator is a Qt application which can be used to map C++ based APIs onto equivalent Java APIs, enabling C++ programmers to easily integrate their own Qt code with Java.
The generator supports a selected subset of C++, covering the most common constructs in Qt. It creates the Java Api by parsing the C++ header files and generating Java source files. It also generates code to tie the Java classes to the C++ classes. Based on the Java Native Interface (JNI), this code ensures that method calls made in Java are redirected to the corresponding functions in the C++ library.
The Qt Jambi generator is a command line tool accepting a header file and a type system specification as arguments:
./generator [options] header-file typesystem-file
The header file should include the relevant modules of the C++ based library. The type system specification is a handwritten XML document listing the types that will be made available in the generated Java API (see the type system documentation for details).
See also: Qt Jambi Generator Example
When running the generator, the header files are preprocessed (i.e., all macros and type definitions are expanded). Then enums, namespaces and classes are mapped according to the type system specification. For each C++ class that is encountered, the generator creates a Java source file and a set of C++ implementation files.
Warning: The Qt Jambi generator is written to handle Qt- based source code, and is not intended for mapping C++ libraries in general.
The Java source file contains one public class with the same name as the original C++ class.
All public and protected members of the C++ class are included in the Java class. For each C++ function, the generator creates a native Java method, and each original member variable generates a set and get method pair since JNI only provides access to native resources through methods. For example, the C++ member variable:
QString text;
generates
String text(); void setText(String text);
in the Java API.
Using the type system specification, it is also possible to rename or remove functions when generating the Java API, as well as changing the access privileges. It is even possible to use the type system to inject arbitrary code into the Java source file, such as an extra member method.
The C++ source file contain two different parts: a shell class and the implementation of the functions declared in the Java source file.
The shell class inherits the original class in the C++ based Qt library, and makes it possible to reimplement virtual functions in Java and to call protected functions in the C++ based library from Java. Whenever an instance of a class is constructed in Java, a corresponding object of the shell class is constructed. If a class has been extended by a user's custom Java class, and one or more of the virtual functions in the class have been reimplemented, the shell class ensures that it is the reimplemented Java implementations that are called.
As with the generated Java source file, it is possible to inject code in the reimplemented virtual functions in the shell classes using the type system specification.
The C++ header file is primarily an implementation detail and can in most cases be ignored. | http://doc.trolltech.com/qtjambi-4.4.0_01/doc/html/com/trolltech/qt/qtjambi-generator.html | crawl-001 | en | refinedweb |
Perfectily good command file snipped
>My configfile tells yarn to keep messages 12 days, max-keep 30 days.
>Although I import a few hundred news per day, expire will only delete less than 20
>messages per day.
Couple of things to try, set max-keep to 12 and/or a shorter expire time.
BTW, you do run expire daily?
>
>What have I done wrong?
Not much, its just that say 200 messages a day x 4k (WAG of average post
size) = 800K per day, x 30 = 24 M per month. However the kicker is that
at no time all the posts 30 days or 12 days old so by aggregation the
news.dat grows.
I set my keep for three days and max keep for three days, expire every
import and my news.dat runs about 5-7 megs. | http://www.vex.net/yarn/list/199706/0064.html | crawl-001 | en | refinedweb |
Language Instinctsby Jon Udell
September 17, 2003
Back in April I made the case for writing weblog entries in XHTML, using CSS for a dual purpose: to control presentation and as hooks for structured search. I then started to accumulate well-formed content, writing CSS class attributes with an eye toward data mining, and flowing XHTML content through my RSS feed. Here's a recap of the basic elements of the plan sketched out in my June column:
The backstory is as follows. I'd noticed that other bloggers had begun to develop an informal convention -- they were using the term "minireview" to identify items that were (or that contained) brief reviews of products. A minireview might be an entire weblog item or just a paragraph within an item. In the monkey-see, monkey-do tradition of the Web, I decided to imitate this behavior. I also wanted to expand its scope. The long-term goal would be to enable me (or anyone) to identity these kinds of elements in a way that would facilitate intelligent search and recombination. But that would require writers to categorize their material, and we all know that's a non-starter. The absence of a universal taxonomy is the least of our problems. Even if such a thing existed (or could exist), we'd be loath to apply it because we are lazy creatures of habit. We invest effort expecting immediate return, not some distant future reward.
What would motivate somebody to tag a chunk of content? It struck me that people care intensely about appearances, self-presentation, and social conformity. Look at the carefully handcrafted arrangements of links on blogrolls -- some ordered by ascending width, some undulating like candlesticks. We do these things despite our inherent laziness because we have seen others do them, because we want to express solidarity with the tribe, and because we hope to be trend-setters, not just trend-followers. Maybe we can leverage the machinery of meme propagation to achieve some semantic enrichment of the Web. Start with visual effects that people can easily create and that other people will want to copy. Tie those effects to tags that can also provide structural hooks. Then exploit the hooks.
RSS, XHTML, and XML databases
In the original plan, RSS was the conduit through which the enhanced content would flow. If a meme did propagate, search services that compiled the XHTML content of blog items into their databases could aggregate along this new axis, thus amplifying the effect. I still envision that scenario, but I'm as much a seeker of instant gratification as the next person, and I wanted immediate use of my own enhanced content. So I extracted the XHTML content I'd been accumulating in my Radio UserLand database, stuck it in a file, and put together a JavaScript/XSLT kit for searching it (1, 2, 3). And then a funny thing happened: the XML file took on a life of its own.
For no particularly good reason, I'd decided to tag quotations like so:
<p class="quotation" source="...">
Over on the Bitflux blog, Roger Fischer noted correctly that this was kind of silly. It unnecessarily invents a 'source' attribute that doesn't exist in XHTML, and that should therefore appear in another namespace. But in any case it's overkill because XHTML affords a natural solution:
<blockquote cite="...">
I agreed with Roger, so I made the change in the XML file (it was just a simple XSLT transform), and made a corresponding change to the canned XPath query that finds quotations in my blog. My next instinct was to republish the affected items. But on second thought, why? In the HTML rendering of my blog, the two styles look the same. And the items had already fallen off the RSS event horizon. Republishing wouldn't cause them to appear in the feed. Even if it did, the purely structural changes would be invisible and thus puzzling to readers.
This creates a slightly odd situation. The canonical version of my weblog is no longer the published one. Rather, it's an XML document-database the structure (but not content) of which is evolving and the API of which is XPath search. At some point I'll probably want to resynchronize the two, but for now I'm just interested to see where the experiment leads.
From pidgin to creole
After I posted the blog entries describing this approach, a number of people asked me to specify the tagging conventions I'm using or intend to use. There is no plan or specification. I'd be satisfied for now if people could routinely and easily create styled elements, associate those elements with CSS attributes, embed the CSS in well-formed content, usefully navigate and search the stuff, and easily adjust the tagging across their own content repositories. Meme propagation could and arguably should drive collective decisions about which kinds of elements to name and what to name them.
In The Language Instinct, Steven Pinker describes the transition from pidgin to creole. A pidgin language, which arises when speakers with no native language in common are thrown together and must communicate, lacks a complete grammar. Amazingly, the children of pidgin speakers spontaneously create creole languages that are grammatically complete. It is perhaps a stretch to relate these processes to the evolution of modes of written communication on the Web. But even if you don't buy the whole analogy, it's worth thinking about how human communities can and do converge on naming conventions and then on a grammar. The process is intensely interactive. People imitate other people's ways of communicating, introducing variations that sometimes catch on and sometimes don't.
I don't think the Semantic Web will come from a specification that tells us how to name and categorize everything. But it could arise, I suspect, from our linguistic instincts and from the social contexts that nurture them. If that's true, then we need to be able to
Speak easily and naturally.
The structural symbols we embed in our writing, when we write for the Web, have to be easy to understand and use. Style attributes strike me as the likely approach because while limited in scope, they're available and can be manipulated in familiar ways.
Hear what we are saying.
At first I was deaf to the structural language I was trying to speak. I'd invent a use for a CSS class attribute and apply it, in what I thought was a consistent way, but it was really just a promise to the future. Some day I'd get around to harvesting what grew from the seeds I was planting. But when I finally did, I found that my tagging conventions had drifted over time. When I closed the feedback loop on my own weblog's content, by making it available to structured search, I could finally hear -- and thus correct -- that drift.
Imitate and be imitated.
My search mechanism has some interesting properties. For example, the canned XPath queries on the form not only make XPath usable for those who don't grok it intuitively, they also advertise the structural hooks that are available. I think of this as an invitation to imitators. Of course I'm an imitator too. When I see a good idea -- for example, Roger Fischer's suggestion -- I want to copy it. Having the searchable content in one place, available to XSLT or even just find-and-replace, makes quick work of that.
The dictionary of the Semantic Web may one day be written. But not until we've done a lot of yammering, a lot of listening, and a lot of imitating. We need to find ways to help these behaviors flourish.
Share your comments on this article in our forum.
(* You must be a member of XML.com to use this feature.)
Comment on this Article
- Genre Evolution
2003-09-18 08:45:48 Len Bullard [Reply]
You are peering into the processes by which genres emerge from practice. The semioticians have a lot to say about that. You might want to check out Daniel Chandler's web pages on the topic. From informal to formal to banal to retro.
len | http://www.xml.com/pub/a/2003/09/17/udell.html | crawl-001 | en | refinedweb |
For client-side work, is XML scriptable with JavaScript? In other
words, can you get something analogous to DHTML with it?
A: On the face of it, this question may seem almost meaningless or,
at least, unnecessary. After all, script and other XML-programming
options already abound besides JavaScript: ASP, Perl, VBScript, Java,
Python...
A couple of considerations make this not such a silly question
after all. First, the questioner specified client-side
processing. This eliminates back-end programming languages such as
Perl, ASP, and Python. Second, JavaScript has a two-pronged advantage
over the languages remaining: it's a simple, cross-platform
solution. If you could actually get it working, any browser capable of
running JavaScript (and, of course, displaying XML in the first place)
could be made to handle the XML exactly the same way. You could
restructure the document tree on-the-fly, for example, or add
completely new elements, attributes, and other nodes to it -- all
without requiring any proprietary languages, and all without having to
know any language more complex than, well, JavaScript.
In researching this question, I found numerous possible solutions
to the problem. Two of them might interest you: the Sourceforge XML for <SCRIPT>
project and Cyril Jandia's ESPX/TinyXSL.
Here's what the XML for <SCRIPT> site has to say about
it:
XML for <SCRIPT> is a simple, non-validating XML DOM
and SAX parser written in JavaScript. It was designed to help web
application designers implement cross platform, client side
manipulation of XML data. XML for <SCRIPT> is licensed under the
terms of the GNU Lesser General Public License (LG <SCRIPT> allows n-tier client side
application development to become a reality.
The benefits of this architecture are many.
In effect, XML for <SCRIPT> allows n-tier client side
application development to become a reality.
ESPX, in Jandia's words, is "an
ECMAScript Parser
for (almost) XML, with namespaces". The "almost"
refers to the fact that ESPX doesn't support DTDs (either internal or
external subset), let alone XML Schema. This may or may not be a fatal
limitation; for instance, if you need to recognize ID-type
attributes, as such, or to use declared entity references, you're out
of luck. On the other hand, ESPX does support quite a
few of HTML 4.0's built-in entity references. As Jandia's summary
implies, it also fully supports the W3C's Namespaces in XML
Recommendation.
Importantly for cross-platform applications, ESPX has been tested
on the three main browsers (Microsoft Internet Explorer,
Netscape/Mozilla, and Opera) not only at their current levels -- which
(to varying degrees) already "know" XML -- but also in "down-level"
versions "without built-in XML support".
As for TinyXSL, Jandia has almost nothing to say except that it's
an "XML transform in-Script
mini-Language" which sits atop an ESPX
framework. Essentially, it's something like an XSLT processor written
in JavaScript (or ECMAScript, as Jandia insists that one of his goals
with both projects was standards compliance). Stylesheets for use with
TinyXSL look quite a bit like plain old XSLT stylesheets, with a
TinyXSL namespace in place of the standard one for XSLT
transformations.
Neither of the above two projects has seen any really recent
updates. XML for <SCRIPT> was last updated about a year ago. The
current ESPX/TinyXSL version is date-stamped March of 2001.
Remember, whether you select either XML for <SCRIPT> or
ESPX/TinyXSL -- or probably any other JavaScript-based alternative --
there's nothing inherent in XML which makes it particularly
"programmable". There's no such thing as a built-in
script element, for one obvious example; even if a
particular vocabulary does include such, what it means depends
entirely on the vocabulary's purpose. (For instance, vocabularies
intended for use in marking up dramatic works and in handwriting
analysis might both include a script element. It probably
would be used in neither case to hold programming instructions,
though.)
script
Related to that first caveat, another implication of using
JavaScript (as opposed to many other languages) to process XML is that
it's meant for use in a web browser/server. While XML for
<SCRIPT> includes a mini-database sample application, the
database in question is retained on a web server which receives form
input from the browser (and makes heavy use of cookies to persist the
data until it's ready to be processed on the back end). If you want to
write some kind of general-purpose XML application which will run
(cross-platform or not) in some context other than the Web, you'll
need to consider some language other than JavaScript.
I have read the XSL-FO
specification. There they have said that XSL-FO formatting
includes three steps:
I am unable to understand these things clearly. Can you please
explain them, with an example?
A: Congratulations on having read the XSL-FO Recommendation. Just
embarking on that task had to require an act of almost unimaginable
willpower! There's no real mystery to the three concepts you've
singled out for your question. Let's look at them one at a time.
This is similar to what a DOM-based XML parser does: it converts a
stream of XML data into an in-memory tree. Specifically, it
constructs what's called a formatting object tree -- essentially a
hierarchy of boxes or containers within which the document's actual
content appears.
For instance, the skeleton of a simple XSL-FO document might look
something like this:
<fo:root [attributes]>
<fo:layout-master-set [attributes]>
<fo:simple-page-master [attributes]>
<fo:region-body
[attributes]>...</fo:region-body>
<fo:region-before
[attributes]>...</fo:region-before>
<fo:region-after
[attributes]>...</fo:region-after>
<fo:region-start
[attributes]>...</fo:region-start>
<fo:region-end
[attributes]>...</fo:region-end>
</fo:simple-page-master>
<fo:page-sequence-master
[attributes]>...</fo:page-sequence-master>
<fo:layout-master set [attributes]>
<fo:page-sequence [attributes]>
<fo:title
[attributes]>...</fo:title>
<fo:static-content
[attributes]>...</fo:static-content>
<fo:flow
[attributes]>...</fo:flow>
</fo:page-sequence>
</fo:root>
To objectify this stream of XML, the formatter converts it to a
tree of objects -- of formatting objects, as shown below:
fo:root
fo:layout-master-set
fo:simple-page-master
fo:region-body
fo:region-before
fo:region-after
fo:region-start
fo:region-end
fo:page-sequence-master
fo:page-sequence
fo:title
fo:static-content
fo:flow
Note that at this point, all that exists is only a rough in-memory
metaphor (as it were) for how the final document will appear.
(The various elements' attributes and text content are also
included in this tree inside the corresponding box, although not shown
above.)
The idea behind the refinement step is that when the final document
is produced, each formatting object (FO) will have traits which
instruct the rendering agent exactly how and where to display that
FO. For instance, a block of text in a top margin (which corresponds
to the fo:region-before FO) might be rendered in a
particular font face, centered horizontally between the margins. These
traits are often specified explicitly in the attributes for a given
FO's corresponding element, and direct mapping of attributes to traits
is one part of refinement.
(Aside: the XSL-FO Recommendation uses the terms "trait" and
"property" more or less interchangeably. Perhaps there's some
distinction between the terms in the spec's authors' minds, but for
all practical purposes you can consider them synonymous.)
Traits can be implied as well as expressed explicitly, however. For
example, many traits are inherited by lower-level FOs from their
higher-level ancestors. Some traits must be calculated based on
evaluating expressions. And some traits (such as a simple
border trait) are shorthand expressions of various
specific traits (such as border-top and
border-style). Deriving traits from these indirect
sources is another (very important) facet of the refinement step.
border
border-top
border-style
Also in XML Q&A
From English to Dutch?
Trickledown Namespaces?
From XML to SMIL
From One String to Many
Getting in Touch with XML Contacts
The final step in XSL-FO processing is the one which produces the
result you're really after when using XSL-FO in the first place: it
assigns a geometric area on each printed page for each block of
content, according to the specifications laid out in the fully-refined
tree of FOs. It moves the abstract, metaphoric expression of the
document's appearance to something which is actually usable by the
target medium, be it printed page, computer monitor, WAP-enabled cell
phone, or whatever.
If you're interested in learning more about XSL-FO -- a big but (I
think) important topic -- I encourage you to consult more full-length
treatments such as Dave Pawson's XSL-FO or my own
Just XSL. (Note that the latter includes full coverage of
XSLT as well as XSL-FO.)
Are you processing XML in the browser using JavaScript? | http://www.xml.com/pub/a/2003/03/26/qa.html | crawl-001 | en | refinedweb |
Create monoidal category framework for arrow desugarer
I'm going to put it into a GHC namespace (GHC.Arrows.Experimental, perhaps) and put instances for Arrow and such in there as well. In a later ticket I'll work on the desugarer, converting erverything into SMC combinators rather than Arrow combinators.
The basic design is here.
The current Arrow story is such a mess that makes it nearly unusable. Hopefully, by breaking it apart and making it more general, it will result in clearer code in both GHC and end-user code. | https://gitlab.haskell.org/ghc/ghc/-/issues/9596 | CC-MAIN-2020-50 | en | refinedweb |
Track experiment runs and deploy.
Deploy your MLflow experiments as an Azure Machine Learning web service. By deploying as a web service, you can apply the Azure Machine Learning monitoring and data drift detection functionalities to your production models..
Deploy and register MLflow models
Deploying your MLflow experiments as an Azure Machine Learning web service allows you to leverage and apply the Azure Machine Learning model management and data drift detection capabilities to your production models.
To do so, you need to
Register your model.
Determine which deployment configuration you want to use for your scenario.
- Azure Container Instance (ACI) is a suitable choice for a quick dev-test deployment.
- Azure Kubernetes Service (AKS) is suitable for scalable production deployments.
The following diagram demonstrates that with the MLflow deploy API you can deploy your existing MLflow models as an Azure Machine Learning web service, despite their frameworks--PyTorch, Tensorflow, scikit-learn, ONNX, etc., and manage your production models in your workspace.
Deploy to ACI
Set up your deployment configuration with the deploy_configuration() method. You can also add tags and descriptions to help keep track of your web service.
from azureml.core.webservice import AciWebservice, Webservice # Set the model path to the model folder created by your run model_path = "model" # Configure aci_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1, tags={'method' : 'sklearn'}, description='Diabetes model', location='eastus2')
Then, register and deploy the model in one step with the Azure Machine Learning SDK deploy method.
(webservice,model) = mlflow.azureml.deploy( model_uri='runs:/{}/{}'.format(run.id, model_path), workspace=ws, model_name='sklearn-model', service_name='diabetes-model-1', deployment_config=aci_config, tags=None, mlflow_home=None, synchronous=True) webservice.wait_for_deployment(show_output=True)
Deploy to AKS
To deploy to AKS, first create an AKS cluster. Create an AKS cluster using the ComputeTarget.create() method. It may take 20-25 minutes to create a new cluster.
from azureml.core.compute import AksCompute, ComputeTarget # Use the default configuration (can also provide parameters to customize) prov_config = AksCompute.provisioning_configuration() aks_name = 'aks-mlflow' # Create the cluster aks_target = ComputeTarget.create(workspace=ws, name=aks_name, provisioning_configuration=prov_config) aks_target.wait_for_completion(show_output = True) print(aks_target.provisioning_state) print(aks_target.provisioning_errors)
Set up your deployment configuration with the deploy_configuration() method. You can also add tags and descriptions to help keep track of your web service.
from azureml.core.webservice import Webservice, AksWebservice # Set the web service configuration (using default here with app insights) aks_config = AksWebservice.deploy_configuration(enable_app_insights=True, compute_target_name='aks-mlflow')
Then, register and deploy the model in one step with the Azure Machine Learning SDK [deploy()](Then, register and deploy the model by using the Azure Machine Learning SDK deploy method.
# Webservice creation using single command from azureml.core.webservice import AksWebservice, Webservice # set the model path model_path = "model" (webservice, model) = mlflow.azureml.deploy( model_uri='runs:/{}/{}'.format(run.id, model_path), workspace=ws, model_name='sklearn-model', service_name='my-aks', deployment_config=aks_config, tags=None, mlflow_home=None, synchronous=True) webservice.wait_for_deployment()
The service deployment can take several minutes.
- Manage your models.
- Monitor your production models for data drift.
- Track Azure Databricks runs with MLflow. | https://docs.microsoft.com/en-us/azure/machine-learning/how-to-use-mlflow?WT.mc_id=devops-9707-dabrady | CC-MAIN-2020-50 | en | refinedweb |
FieldDateRenderer control¶
This control renders date string as a simple text.
Covered Fields¶
- Date and Time
How to use this control in your solutions¶
- Check that you installed the
@pnp/spfx-controls-reactdependency. Check out the getting started page for more information about installing the dependency.
- Import the following modules to your component:
import { FieldDateRenderer } from "@pnp/spfx-controls-react/lib/FieldDateRenderer";
- Use the
FieldDateRenderercontrol in your code as follows:
<FieldDateRenderer text={event.fieldValue} className={'some-class'} cssProps={{ background: '#f00' }} />
Note: FieldDateRenderer doesn't provide functionality to render date in friendly format. It just renders the provided text as is. To learn more about friendly formatting please refer to
FieldRendererHelper implementation.
Implementation¶
The FieldDateRenderer component can be configured with the following properties: | https://pnp.github.io/sp-dev-fx-controls-react/controls/fields/FieldDateRenderer/ | CC-MAIN-2020-50 | en | refinedweb |
10-16-2020 05:46 AM
Hello to anyone out there reading this.
I ran into a peculiar issue this morning while testing some Microsoft Word to Excel transfer scripting I had started the other day. For some reason Microsoft Excel has taken to leaving small rectangular looking characters in every cell that had data inputted. These characters do disappear once I attempt to edit the cell but if the user has to F2 every cell to rid themselves of these tiny life plaguing boxes it makes my work practically useless as it aims to increase the efficiency of the worker and not have copy/paste functions be simpler. I haven't been able to find any other reference to my little boxes and have inserted a small screenshot for any clarification.
Please someone help get rid of these forsaken boxes.
Hopefully this issue can be resolved sooner rather than later. Or I might have to ditch the project entirely.
Osten24
10-16-2020 05:49 AM
10-16-2020 06:42 AM
And I don't suppose this would help but in case it could alleviate the circumstances I've attached my working c# scripting for this transfer concept.
I know it's rusty I just tossed it together quickly the other day.
using Word = Microsoft.Office.Interop.Word; using Excel = Microsoft.Office.Interop.Excel; using System; using System.Windows.Forms; namespace WordTesting3 { class Program { [STAThreadAttribute] static void Main(string[] args) { ConsoleKeyInfo cki; Console.WriteLine("Please Use The Executable Properly, Allow The Program To Do What It Is Meant To Do, Do Not Close Any Working Files, Do Not Edit Any Working Files. Will Result In Memory Loss"); Console.WriteLine("Press ESC to Escape"); Console.WriteLine("Press any key to Continue..."); cki = Console.ReadKey(); if(cki.Key == ConsoleKey.Escape) { System.Environment.Exit(1); } do { Transfer(); Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine("Press ESC to Escape"); Console.WriteLine("Press any key to Continue..."); Console.WriteLine(""); cki = Console.ReadKey(); Console.WriteLine(""); } while (cki.Key != ConsoleKey.Escape); } static void Transfer() { try { //Word var openFileDialogWord = new OpenFileDialog(); // Set filter options and filter index openFileDialogWord.Filter = "Word Documents (.docx)|*.docx|All files (*.*)|*.*"; openFileDialogWord.FilterIndex = 1; openFileDialogWord.Multiselect = false; // Call the ShowDialog method to show the dialog box. openFileDialogWord.ShowDialog(); var word = new Word.Application(); object miss = System.Reflection.Missing.Value; object path = openFileDialogWord.FileName; object readOnly = true; var docs = word.Documents.Open(ref path, ref miss, ref readOnly, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss, ref miss); //Excel var openFileDialogExcel = new OpenFileDialog(); // Set filter options and filter index openFileDialogExcel.Filter = "Excel Documents (*.xlsx)|*.xlsx|All files (*.*)|*.*"; openFileDialogExcel.FilterIndex = 1; openFileDialogExcel.Multiselect = false; // Call the ShowDialog method to show the dialog box. openFileDialogExcel.ShowDialog(); var excel = new Excel.Application(); object exmiss = System.Reflection.Missing.Value; string expath = openFileDialogExcel.FileName; object exreadOnly = true; var wb = excel.Workbooks.Open(expath); var wks = wb.Worksheets[1]; //Begins Transfer excel.Visible = false; word.Visible = true; Console.WriteLine(""); var rowCount = 0; //Will Parse Out Values From Every Cell From Every Table And Compile It All Into One Table. Presumably A Copy Of The Last. Will Need Revisement foreach (Word.Table tb in docs.Tables) { for (int row = 1; row <= tb.Rows.Count; row++) { rowCount++; for (int col = 1; col <= tb.Columns.Count; col++) { try { var cell = tb.Cell(row, col); var text = cell.Range.Text; Console.WriteLine(text); wks.Cells[rowCount, col].Value = cell; } catch (Exception) { continue; } // text now contains the content of the cell. } } } //MinimizeConsoleWindow(); Future Reference excel.Visible = true; docs.Close(); word.Quit(); wb.Close(); excel.Quit(); } catch (Exception) { Console.WriteLine("ERROR"); } } public static void MinimizeConsoleWindow(bool visible) { //More Complicated Than It Seems } } }
10-16-2020 08:24 AM
10-16-2020 08:24 AM
Can't explain why the "boxes" appear, but can perhaps help get rid of them. Copy the "box" from within a cell. Select all cells. Press Ctrl- H (Find and replace). Paste the the "box" symbol in the "Find" field and leave the "Replace with" blank. Press "Replace all", OK and Close. This should remove all the "box" symbols in the entire sheet in one go.
10-16-2020 08:46 AM - edited 10-16-2020 08:56 AM
10-16-2020 08:46 AM - edited 10-16-2020 08:56 AM
Oh you almost made my day. Small issue though. As the box disappears once the cell begins edit, I can't quite only snag the box. And if I copy/paste the entire cell the box also decides to go. There is a development though, I believe this may be an issue of my script inserting the values in as var rather string or int. Possibly more a c# issue rather excel.
EDIT: Possible additional info. When cell is copied and pasted into outside source it is represented by quotations rather the evil rectangle. Another tidbit is my venture into variable types did not work either.
10-16-2020 12:35 PMSolution
Discovered the fix for the issue. It seems as if this was more an issue between communications with my c# scripting and word, rather excel. Excel I am sorry for questioning your abilities. He just can't read asciii symbols and apparently expresses them as boxes. I simply added the below code if anyone was ever encountering this issue when using Microsoft.Office.Interop interactions.
text = text.Substring(0, text.Length - 2);
Simply removed the last two extra characters. I'd rather a better solution but this should get me through development. | https://techcommunity.microsoft.com/t5/excel/tiny-life-plaguing-boxes/m-p/1788884 | CC-MAIN-2020-50 | en | refinedweb |
Is it possible to get a reference to the primary Stage in a running JavaFX application ?.
The context of this question is that I would like to write a library that manipulates a JavaFX interface from another language (Prolog). In order to do this, my library requires access to the primary Stage. The objective is that the programmer of the JavaFX application does not have to explicit store a reference to the Stage object in the start method, so it should be transparent for the user interface designer (this is a related question in case more details are needed).
Part of this problem is getting a reference to the primary Stage object of the original JavaFX application ,so I was wondering if something like a static method somewhere could give me access to that.
Not sure of the right decision, but it works for my case.
Create static field in main class with getter and setter:
public class MyApp extends Application { private static Stage pStage; @Override public void start(Stage primaryStage) { setPrimaryStage(primaryStage); pStage = primaryStage; ... } public static Stage getPrimaryStage() { return pStage; } private void setPrimaryStage(Stage pStage) { MyApp.pStage = pStage; } }
Next, in the necessary place calling getter. For example:
stageSecond.initOwner(MyApp.getPrimaryStage()); | https://javafxpedia.com/en/knowledge-base/15805881/how-can-i-obtain-the-primary-stage-in-a-javafx-application- | CC-MAIN-2020-50 | en | refinedweb |
- Language: en
PostgreSQL specific database constraints¶
PostgreSQL supports additional data integrity constraints available from the
django.contrib.postgres.constraints module. They are added in the model
Meta.constraints option.
ExclusionConstraint¶
- class
ExclusionConstraint(*, name, expressions, index_type=None, condition=None, deferrable=None, include=None, opclasses=())¶
Creates an exclusion constraint in the database. Internally, PostgreSQL implements exclusion constraints using indexes. The default index type is GiST. To use them, you need to activate the btree_gist extension on PostgreSQL. You can install it using the
BtreeGistExtensionmigration operation.
If you attempt to insert a new row that conflicts with an existing row, an
IntegrityErroris raised. Similarly, when update conflicts with an existing row.
expressions¶
An iterable of 2-tuples. The first element is an expression or string. The
second element is an SQL operator represented as a string. To avoid typos, you
may use
RangeOperators which maps the
operators with strings. For example:
expressions=[ ('timespan', RangeOperators.ADJACENT_TO), (F('room'), RangeOperators.EQUAL), ]
Restrictions on operators.
Only commutative operators can be used in exclusion constraints.
index_type¶
The index type of the constraint. Accepted values are
GIST or
SPGIST.
Matching is case insensitive. If not provided, the default index type is
GIST.
condition¶
A
Q object that specifies the condition to restrict
a constraint to a subset of rows. For example,
condition=Q(cancelled=False).
These conditions have the same database restrictions as
django.db.models.Index.condition.
deferrable¶
Set this parameter to create a deferrable exclusion constraint. Accepted values
are
Deferrable.DEFERRED or
Deferrable.IMMEDIATE. For example:
from django.contrib.postgres.constraints import ExclusionConstraint from django.contrib.postgres.fields import RangeOperators from django.db.models import Deferrable ExclusionConstraint( name='exclude_overlapping_deferred', expressions=[ ('timespan', RangeOperators.OVERLAPS), ], deferrable=Deferrable.DEFERRED, )
By default constraints are not deferred. A deferred constraint will not be enforced until the end of the transaction. An immediate constraint will be enforced immediately after every command.
Warning
Deferred exclusion constraints may lead to a performance penalty.
include¶
A list or tuple of the names of the fields to be included in the covering
exclusion constraint as non-key columns. This allows index-only scans to be
used for queries that select only included fields
(
include) and filter only by indexed fields
(
expressions).
include is supported only for GiST indexes on PostgreSQL 12+.
opclasses¶
The names of the PostgreSQL operator classes to use for this constraint. If you require a custom operator class, you must provide one for each expression in the constraint.
For example:
ExclusionConstraint( name='exclude_overlapping_opclasses', expressions=[('circle', RangeOperators.OVERLAPS)], opclasses=['circle_ops'], )
creates an exclusion constraint on
circle using
circle_ops.
Examples¶
The following example restricts overlapping reservations in the same room, not taking canceled reservations into account:
from django.contrib.postgres.constraints import ExclusionConstraint from django.contrib.postgres.fields import DateTimeRangeField, RangeOperators from django.db import models from django.db.models import Q class Room(models.Model): number = models.IntegerField() class Reservation(models.Model): room = models.ForeignKey('Room', on_delete=models.CASCADE) timespan = DateTimeRangeField() cancelled = models.BooleanField(default=False) class Meta: constraints = [ ExclusionConstraint( name='exclude_overlapping_reservations', expressions=[ ('timespan', RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL), ], condition=Q(cancelled=False), ), ]
In case your model defines a range using two fields, instead of the native
PostgreSQL range types, you should write an expression that uses the equivalent
function (e.g.
TsTzRange()), and use the delimiters for the field. Most
often, the delimiters will be
'[)', meaning that the lower bound is
inclusive and the upper bound is exclusive. You may use the
RangeBoundary that provides an
expression mapping for the range boundaries. For example:
from django.contrib.postgres.constraints import ExclusionConstraint from django.contrib.postgres.fields import ( DateTimeRangeField, RangeBoundary, RangeOperators, ) from django.db import models from django.db.models import Func, Q class TsTzRange(Func): function = 'TSTZRANGE' output_field = DateTimeRangeField() class Reservation(models.Model): room = models.ForeignKey('Room', on_delete=models.CASCADE) start = models.DateTimeField() end = models.DateTimeField() cancelled = models.BooleanField(default=False) class Meta: constraints = [ ExclusionConstraint( name='exclude_overlapping_reservations', expressions=( (TsTzRange('start', 'end', RangeBoundary()), RangeOperators.OVERLAPS), ('room', RangeOperators.EQUAL), ), condition=Q(cancelled=False), ), ] | https://docs.djangoproject.com/en/dev/ref/contrib/postgres/constraints/ | CC-MAIN-2020-50 | en | refinedweb |
Mule Server Notifications
Mule provides an internal notification mechanism that you can use to access changes that occur on the Mule Server, such as adding a flow component, a request for authorization failing, or Mule starting. You can set up your agents or flow components to react to these notifications.
Configuring Notifications
Message notifications provide a snapshot of all information sent into and out of the Mule Server. Mule fire these notifications whenever it receives or sends a message. in your spring configuration file, specifying the class of the type of notification you want to receive:
<bean name="notificationLogger" class="org.myfirm.ProcessorNotificationStore"/>
And then, add the reference for your spring configuration:
<spring:config
Next, you specify the notifications you want to receive using the
<notification> element, and then register the listeners using the
<notification-listener> element:
<notifications> <notification event="MESSAGE-PROCESSOR"/> <notification-listener </notifications>
When you specify the MESSAGE-PROCESSOR notification, a notification is sent before and after a message processor is invoked. Because the listeners implement the interface for the type of notification they want to receive, the listeners receive the correct notifications.
For example, the
ProcessorNotificationLogger class would implement
org.mule.runtime.api.notification.MessageProcessorNotificationListener:
public class ProcessorNotificationLogger implements MessageProcessorNotificationListener<MessageProcessorNotification> { @Override public void onNotification(MessageProcessorNotification notification) { // write here the logic to process the notification event } }
For a list of notification types, see Notifications Configuration Reference. For a list of notification listener interfaces, see Notification Interfaces below.
Specifying a Different Interface
If you want to change the interface associated with a notification, you specify the new interface with the
interface-class attribute:
<notifications> <notification event="COMPONENT-MESSAGE" interface- </notifications>
Configuring a Custom Notification
If you create a custom notification, you also specify the
event-class attribute:
<notifications> <notification event="CUSTOM" event- </notifications>
Disabling Notifications
If you want to block a specific interface from receiving a notification, you specify it with the
<disable-notification> element. You can specify the notification type (event), event class, interface, and/or interface class to block.
<notifications> <disable-notification </notifications>
Using Subscriptions
When registering a listener, you can specify that it only receives notifications from a specific component using the
subscription attribute. For example, to specify that the listener only receives notifications from a flow component called "MyService1", you would configure the listener as follows:
<notification-listener <object name="endpointNotificationLogger" class="org.myfirm.EndpointNotificationLogger"/>
To register interest in notifications from all flow components with "Service" in the name, you would use a wildcard string as follows:
<notification-listener
For more information, see Registering Listeners Programmatically below.
Firing Custom Notifications
Objects can fire custom notifications in Mule to notify custom listeners. For example, a discovery agent might fire a Client Found notification when a client connects.
You fire a custom notification as follows:
CustomNotification n = new CustomNotification("Hello"); notificationDispatcher.dispatch(n);
Any objects implementing
CustomNotificationListener will receive this notification. It’s a good idea to extend
CustomNotification and define actions for your custom notification type. For example:
DiscoveryNotification n = new DiscoveryNotification(client, DiscoveryNotification.CLIENT_ADDED); notificationDispatcher.dispatch(n);
Notification Interfaces
The following table describes the Mule server notifications and the interfaces in the
org.mule.runtime.api.notification package. An object can implement one of these interfaces to become a listener for the associated notification. All listeners extend the
NotificationListener interface.
The listener interfaces all have a single method:
public void onNotification(T notification);
where T is a notification class (listener class without the 'Listener' at the end).
Depending on the listener implemented, only certain notifications will be received. For example, if the object implements
ManagementNotificationListener, only notifications of type
ManagementNotification will be received. Objects can implement more than one listener to receive more types of notifications.
Registering Listeners Programmatically
You can register listeners as follows:
notificationListenerRegistry.registerListener(listener);
or:
notificationListenerRegistry.registerListener(listener, selector);
where
listener is a
NotificationListener<N> instance and
selector is a
Predicate<N> that works as a filter to apply on a fired notification before calling the listener with it.
Notification Action Codes
Each notification has an action code that determines the notification type. You can query the action code to determine its type. For example:
MyObject.java
public class MyObject implements ConnectionNotificationListener<ConnectionNotification> { (...) public void onNotification(ConnectionNotification notification) { if (valueOf(ConnectionNotification.CONNECTION_FAILED).equals(notification.getAction().getIdentifier())) { // write here the logic to handle the connection failed notification } } } | https://docs.mulesoft.com/mule-runtime/4.3/mule-server-notifications | CC-MAIN-2020-50 | en | refinedweb |
- NAME
- SYNOPSIS
- DESCRIPTION
- FUNCTIONS
- SEE ALSO
- TODO
- AUTHOR
- LICENSE
NAME
CAD::Mesh3D - Create and Manipulate 3D Vertexes and Meshes and output for 3D printing
SYNOPSIS
use CAD::Mesh3D qw(+STL :create :formats); my $vect = createVertex(); my $tri = createFacet($v1, $v2, $v3); my $mesh = createMesh(); $mesh->addToMesh($tri); ... $mesh->output(STL => $filehandle_or_filename, $ascii_or_binary);
DESCRIPTION
A framework to create and manipulate 3D vertexes and meshes, suitable for generating STL files (or other similar formats) for 3D printing.
A Mesh is the container for the surface of the shape or object being generated. The surface is broken down into locally-flat pieces known as Facets. Each Facet is a triangle made from three points, called Vertexes (also spelled as vertices). Each Vertex is made up of three x, y, and z coordinates, which are just floating-point values to represent the position in 3D space.
FUNCTIONS
OBJECT CREATION
The following functions will create the Mesh, Triangle, and Vertex array-references. They can be imported into your script en masse using the
:create tag.
createVertex
my $v = createVertex( $x, $y, $z );
Creates a Vertex using the given
$x, $y, $z floating-point values to represent the x, y, and z coordinates in 3D space.
createFacet
my $f = createFacet( $a, $b, $c );
Creates a Facet using the three Vertex arguments as the corner points of the triangle.
Note that the order of the Facet's Vertexes matters, and follows the right-hand rule to determine the "outside" of the Facet: if you are looking at the Facet such that the points are arranged in a counter-clockwise order, then everything from the Facet towards you (and behind you) is "outside" the surface, and everything beyond the Facet is "inside" the surface.
createQuadrangleFacets
my @f = createQuadrangleFacets( $a, $b, $c, $d );
Creates two Facets using the four Vertex arguments as the corners of a quadrangle (like with
createFacet, the arguments are ordered by the right-hand rule). This returns a list of two triangular Facets, for the triangles ABC and ACD.
getx
gety
getz
my $v = createVertex(1,2,3); my $x = getx($v); # 1 my $y = getx($v); # 2 my $z = getx($v); # 3
Grabs the individual x, y, or z coordinate from a vertex
createMesh
my $m = createMesh(); # empty my $s = createMesh($f, ...); # pre-populated
Creates a Mesh, optionally pre-populating the Mesh with the supplied Facets.
addToMesh
$mesh->addToMesh($f); $mesh->addToMesh($f1, ... $fN); addToMesh($mesh, $f1, ... $fN);
Adds Facets to an existing Mesh.
MATH FUNCTIONS
use CAD::Mesh3D qw/:math/;
Most of the math on the three-dimensional Vertexes are handled by Math::Matrix::Real; all the matrix methods will work on Vertexes, as documented for Math::Matrix::Real. However, three-dimensional math can take some special functions that aren't included in the generic matrix library. CAD::Mesh3D implements a few of these special-purpose functions for you.
They can be called as methods on the Vertex variables, or imported as functions into your script using the
:math tag.
unitDelta
my $uAB = unitDelta( $A, $B ); # or my $uAB = $A->unitDelta($B);
Returns a vector (using same structure as a Vertex), which gives the direction from Vertex A to Vertex B. This is scaled so that the vector has a magnitude of 1.0.
unitCross
my $uN = unitCross( $uAB, $uBC ); # or my $uN = $uAB->unitCross($uBC);
Returns the cross product for the two vectors, which gives a vector perpendicular to both. This is scaled so that the vector has a magnitude of 1.0.
A typical usage would be for finding the direction to the "outside" (the normal-vector) using the right-hand rule. For a Facet with points A, B, and C, first, find the direction from A to B, and from B to C; the
unitCross of those two deltas gives you the normal-vector (and, in fact, that's how
facetNormal() is implemented).
my $uAB = unitDelta( $A, $B ); my $uBC = unitDelta( $B, $C ); my $uN = unitCross( $uAB, $uBC );
facetNormal
unitNormal
my $uN = facetNormal( $facet ); # or my $uN = $facet->normal(); # or my $uN = unitNormal( $vertex1, $vertex2, $vertex3 )
Uses
unitDelta() and
unitCross() to find the normal-vector for the given Facet, given the right-hand rule order for the Facet's vertexes.
FORMATS
If you want to be able to output your mesh into a format, or input a mesh from a format, you need to enable them. This makes it simple to incorporate an add-on
CAD::Mesh3D::NiftyFormat.
Note to developers: CAD::Mesh3D::ProvideNewFormat documents how to write a submodule (usually in the
CAD::Mesh3D namespace) to provide the appropriate input and/or output functions for a given format. CAD::Mesh3D:STL is a format that ships with CAD::Mesh3D, and provides an example of how to implement a format module.
The
enableFormat,
output, and
input functions can be imported using the
:formats tag.
enableFormat
use CAD::Mesh3D qw/+STL :formats/; # for the format 'STL' # or enableFormat( $format ) # or enableFormat( $format => $moduleName )
$moduleName should be the name of the module that will provide the
$format routines. It will default to 'CAD::Mesh3D::$format'. The
$format is case-sensitive, so
enableFormat( 'Stl' ); enableFormat( 'STL' ); will try to enable two separate formats.
output
Output the Mesh to a 3D output file in the given format
use CAD::Mesh3D qw/+STL :formats/; $mesh->output('STL' => $file); $mesh->output('STL' => $file, @args );
Outputs the given
$mesh to the indicated file.
The
$file argument is either an already-opened filehandle, or the name of the file (if the full path is not specified, it will default to your script's directory), or "STDOUT" or "STDERR" to direct the output to the standard handles. output; it is possible that some do not. (For example, some formats may have a binary structure that is free to read, but requires paying a license to write.)
input
use CAD::Mesh3D qw/+STL :formats/; my $mesh = input( 'STL' => $file, @args );
Creates a Mesh by reading the given file using the specified format.
The
$file argument is either an already-opened filehandle, or the name of the file (if the full path is not specified, it will default to your script's directory), or "STDIN" to grab the input from the standard input handle. input; it is possible that some do not. (For example, some formats, like a PNG image, may not contain the necessary 3d information to create a mesh.)
SEE ALSO
Math::Vector::Real - This provides matrix math
The Vertexes were implemented using this module, to easily handle the Vertex and Facet calculations.
CAD::Format::STL - This provides simple input and output between STL files and an array-of-arrays perl data structure.
Adding more features to this module (especially the math on the Vertexes and
Facets) and making a generic interface (which can be made to work with other formats) were the two primary motivators behind the CAD::Mesh3D development.
This module is still used as the backend for the CAD::Mesh3D::STL format-module.
TODO
Add more math for Vertexes and Facets, as new functions are identified as being useful.
AUTHOR
Peter C. Jones
<petercj AT cpan DOT org>
LICENSE
This program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as published by the Free Software Foundation; or the Artistic License.
See for more information. | https://metacpan.org/pod/CAD::Mesh3D | CC-MAIN-2020-50 | en | refinedweb |
The Dataflow SDKs use a specialized class called
PCollection to represent data in a
pipeline. A
PCollection represents a multi-element data set.
You can think of a
PCollection as "pipeline" data. Dataflow's
transforms use
PCollections as inputs and
outputs; as such, if you want to work with data in your pipeline, it must be in the form of a
PCollection. Each
PCollection is owned by a specific
Pipeline object, and only that
Pipeline object can use it.
IMPORTANT: This document contains information about unbounded
PCollections and Windowing. These concepts refer to the Dataflow Java SDK
only, and are not yet available in the Dataflow Python SDK.
PCollection Characteristics
A
PCollection represents a potentially large, immutable "bag" of elements.
There is no upper limit on how many elements a
PCollection can contain; any given
PCollection might fit in memory, or it might represent a very large data set backed
by a persistent data store.
Java
The elements of a
PCollection can be of any type, but must all be of the same type.
However, Dataflow needs to be able to encode each individual element as a byte string in order to
support distributed processing. The Dataflow SDKs provide a
Data Encoding mechanism that includes built in
encodings for commonly used types and support for specifying custom encodings as needed.
Creating a valid encoding for an arbitrary type can be challenging, but you can
construct custom encoding for simple structured types.
An important data type for large scale data processing is the key/value pair. The
Dataflow SDKs use the class
KV<K, V> to represent key/value pairs.
Python
An important data type for large scale data processing is the key/value pair. The Dataflow Python SDK uses 2-tuples to represent key/value pairs.
PCollection Limitations
A
PCollection has several key aspects in which it differs from a regular collection
class:
- A
PCollectionis immutable. Once created, you cannot add, remove, or change individual elements.
- A
PCollectiondoes not support random access to individual elements.
- A
PCollectionbelongs to the pipeline in which it is created. You cannot share a
PCollectionbetween
Pipelineobjects.
A
PCollection may be physically backed by data in existing storage, or it may
represent data that has not yet been computed. As
such, the data in a
PCollection is immutable. You can use a
PCollection
in computations that generate new pipeline data (as a new
PCollection); however, you
cannot change the elements of an existing
PCollection once it has been created.
A
PCollection does not store data, per se; remember that a
PCollection may have too many elements to fit in local memory where your Dataflow
program is running. When you create or transform a
PCollection, data isn't copied
or moved in memory as with some regular container classes. Instead, a
PCollection
represents a potentially very large data set in the cloud.
Bounded and Unbounded PCollections
A
PCollection's size can be either bounded or unbounded, and the
boundedness (or unboundedness) is determined when you create the
PCollection. Some
root transforms create bounded
PCollections, while others create unbounded ones; it
depends on the source of your input data.
Bounded PCollections
Your
PCollection is bounded if it represents a fixed data set, which has a
known size that doesn't change. An example of a fixed data set might be "server logs from the
month of October", or "all orders processed last week."
TextIO and
BigQueryIO root transforms create bounded
PCollections.
Data sources that create bounded
PCollections include:
Java
TextIO
BigQueryIO
DatastoreIO
- Custom bounded data sources you create using the Custom Source API
Python
TextIO
BigQueryIO
- Custom bounded data sources you create using the Custom Source API
Data sinks that accept bounded
PCollections include:
Java
TextIO
BigQueryIO
DatastoreIO
- Custom bounded data sinks you create using the Custom Sink API
Python
TextIO
BigQueryIO
- Custom bounded data sinks you create using the Custom Sink API
Unbounded PCollections
Your
PCollection is unbounded if it represents a continuously updating data
set, or streaming data. An example of a continuously updating data set might be "server logs
as they are generated" or "all new orders as they are processed."
PubsubIO root
transforms create unbounded
PCollections.
Some sources, particularly those that create unbounded
PCollections (such as
PubsubIO), automatically append a timestamp to each element of the collection.
Data sources that create unbounded
PCollections include:
PubsubIO
- Custom unbounded data sources you create using the Custom Source API
Data sinks that accept unbounded
PCollections include:
PubsubIO
BigQueryIO
Processing Characteristics
The bounded (or unbounded) nature of your
PCollection affects how Dataflow processes
your data. Bounded
PCollections can be processed using batch jobs, which might read
the entire data set once, and perform processing in a finite job. Unbounded
PCollections must be processed using streaming jobs, as the entire collection can
never be available for processing at any one time.
When grouping unbounded
PCollections, Dataflow requires a concept called
Windowing to divide a continuously updating data set into
logical windows of finite size. Dataflow processes each window as a bundle, and processing continues as
the data set is generated. See the following section on Timestamps and
Windowing for more information.
PCollection Element Timestamps
Each element in a
PCollection has an associated timestamp.
Timestamps are useful for
PCollections that contain elements with an inherent notion
of time. For example, a
PCollection of orders to process may use the time an order
was created as the element timestamp.
The timestamp for each element is initially assigned by the source that creates the
PCollection. Sources that create unbounded
PCollection often assign each new element a timestamp according to
when it was added to the unbounded
PCollection.
Java
Data sources that produce fixed data sets, such as
BigQueryIO or
TextIO, also assign timestamps to each element; however, these data sources typically
assign the same timestamp (
Long.MIN_VALUE) to each element.. See
Assigning Timestamps for more
information.
Python.
Windowing
The timestamps associated with each element in a
PCollection are used for a concept
called Windowing. Windowing divides the elements of a
PCollection according to their timestamps. Windowing can be used on all
PCollections, but is required for some computations over unbounded
PCollections in order to divide the continuous data stream in finite chunks for
processing.
See the section on Windowing for more information on how to use Dataflow's Windowing concepts in your pipeline.
Creating a PCollection
To work with a data set in a Cloud Dataflow pipeline, you'll need to create a
PCollection to represent the data, wherever it is stored. The Dataflow
SDKs provide two principal ways to create an initial
PCollection:
- You can read the data from an external data source, such as a file.
- You can create a
PCollectionof data that's stored in an in-memory collection class.
Reading External Data
See Pipeline I/O for more information on reading data from an external data source.
Creating a PCollection from Data In Local Memory
You can create a
PCollection out of data in local memory so that you can use that
data in your pipeline's transforms. Typically, you use data from local memory to test your
pipeline with smaller data sets, and to reduce your pipeline's dependence on external I/O while
testing.
Java
To create a
PCollection from an in-memory Java
Collection, you
apply the
Create transform.
Create is a root
PTransform provided by the Dataflow SDK for Java.
Create accepts a
Java
Collection and a
Coder object, which specifies how the elements
in the
Collection should be encoded.
The following code sample creates a
PCollection of
String, representing
individual lines of text, from a Java
List:
//, "); PipelineOptions options = PipelineOptionsFactory.create(); Pipeline p = Pipeline.create(options); p.apply(Create.of(LINES)).setCoder(StringUtf8Coder.of()) // create the PCollection
The code above uses
Create.of, which produces a
PCollection
containing the specified elements. Note that if your pipeline uses
windowing, you should use
Create.timestamped
instead.
Create.timestamped produces a
PCollection containing the
specified elements with specified timestamps.
Python
To create a
PCollection, you apply the
Create transform.
Create is a standard transform provided by the Dataflow Python SDK.
import apache_beam as beam from apache_beam.options.pipeline_options import PipelineOptions # argv = None # if None, uses sys.argv pipeline_options = PipelineOptions(argv) with beam.Pipeline(options=pipeline_options) as pipeline: lines = ( pipeline | beam.Create([ 'To be, or not to be: that is the question: ', "Whether 'tis nobler in the mind to suffer ", 'The slings and arrows of outrageous fortune, ', 'Or to take arms against a sea of troubles, ', ]))
Using PCollection with Custom Data Types
You can create a
PCollection where the element type is a custom data type that you
provide. This can be useful if you need to create a collection of your own class or
structure with specific fields, like a Java class that holds a customer's name, address, and phone
number.
When you create a
PCollection of a custom type, you'll need to provide a
Coder for that custom type. The
Coder tells the Dataflow
service how to serialize and deserialize the elements of your
PCollection as your
dataset is parallelized and partitioned out to multiple pipeline worker instances; see
data encoding for more information.
Dataflow will attempt to infer a
Coder for any
PCollection for which
you do not explicitly set a
Coder. The default
Coder for a custom type is
SerializableCoder, which uses Java serialization. However, Dataflow recommends
using
AvroCoder as the
Coder when possible.
You can register
AvroCoder as the default coder for your data type by using your
Pipeline object's
CoderRegistry. Annotate your class as
follows:
Java
@DefaultCoder(AvroCoder.class) public class MyClass { ... }
To ensure that your custom class is compatible with
AvroCoder, you might need to
add some additional annotations—for example, you must annotate null fields in your data type
with
org.apache.avro.reflect.Nullable. See the API for Java reference documentation for
AvroCoder
and the package
documentation for
org.apache.avro.reflect for more information.
Dataflow's TrafficRoutes example pipeline
creates a
PCollection whose element type is a custom class called
StationSpeed.
StationSpeed registers
AvroCoder as its
default coder as follows:
Java
/** * This class holds information about a station reading's average speed. */ @DefaultCoder(AvroCoder.class) static class StationSpeed { @Nullable String stationId; @Nullable Double avgSpeed; public StationSpeed() {} public StationSpeed(String stationId, Double avgSpeed) { this.stationId = stationId; this.avgSpeed = avgSpeed; } public String getStationId() { return this.stationId; } public Double getAvgSpeed() { return this.avgSpeed; } } | https://cloud.google.com/dataflow/model/pcollection?hl=da | CC-MAIN-2020-50 | en | refinedweb |
Linux Unix Training Classes in Frankfort, Kentucky
Learn Linux Unix in Frankfort, Kentucky and surrounding areas via our hands-on, expert led courses. All of our classes either are offered on an onsite, online or public instructor led basis. Here is a list of our current Linux Unix related training offerings in Frankfort, Kentucky:
- Docker
9 December, 2019 - 11 December, 2019
- Certified Scrum Product Owner (CSPO)
13 November, 2019 - 14 November, 2019
- Enterprise Linux System Administration
2 December, 2019 - 6 December, 2019
- KUBERNETES ADMINISTRATION WITH HELM
18 November, 2019 - 21 November, 2019
- 55232: Writing Analytical Queries for Business Intelligence
6 January, 2020 - 8.
Checking to see if a file exists is a two step process in Python. Simply import the module shown below and invoke the isfile function:
import os.path os.path.isfile(fname)… | https://www.hartmannsoftware.com/Training/Linux/Frankfort-Kentucky | CC-MAIN-2019-47 | en | refinedweb |
vcs, vcsa −.
This program displays the character and screen attributes
under the cursor of the second virtual console, then changes
the background color there:
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
void main()
{
int fd;
struct {char lines, cols, x, y;} scrn;
char ch, attrib;
fd = open("/dev/vcsa2", O_RDWR);
(void)read(fd, &scrn, 4);
(void)lseek(fd, 4 + 2*(scrn.y*scrn.cols + scrn.x),
0);
(void)read(fd, &ch, 1);
(void)read(fd, &attrib, 1);
printf("ch=’%c’ attrib=0x%02x\n",
ch, attrib);
attrib ^= 0x10;
(void)lseek(fd, -1, 1);
(void)write(fd, &attrib, 1);
}
/dev/vcs[0-63]
/dev/vcsa[0-63]
Andries Brouwer <aeb@cwi.nl>
Introduced with version 1.1.92 of the Linux kernel.
console(4), tty(4), ttys(4),
selection(1) | http://alvinalexander.com/unix/man/man4/vcsa.4.shtml | CC-MAIN-2019-47 | en | refinedweb |
Objects created in real time
Hi,
I an converting all my C.O.F.F.E.E scripts to python.
But I have a problem with python at the real-time display of the objects I create.
I synthesized this problem in the simplified script below.
If I press on the button <Creation null polygon> the polygon will only show on the screen when I close the plugin window.
How to make the polygon appear on the screen without being obliged to close the plugin window ?
import c4d from c4d import gui, documents button_1 = 1000 class MyDialog(c4d.gui.GeDialog): def CreateLayout(self): self.SetTitle("Creation polygon") self.AddButton(button_1, c4d.BFH_LEFT, 300, 24, "Creation null polygon") self.GroupEnd() return True def Command(self, cid, msg): if cid == button_1: polygon = c4d.BaseObject(c4d.Opolygon) doc = c4d.documents.GetActiveDocument() doc.InsertObject(polygon) c4d.EventAdd() return True class MyCommandData(c4d.plugins.CommandData): def Execute(self, doc): dlg = MyDialog() dlg.Open(c4d.DLG_TYPE_MODAL, -1, -1, 400, 200) dlg.InitValues(self) return True if __name__ == "__main__": c4d.plugins.RegisterCommandPlugin(id=10000015, str="Creation polygon", info=0, icon=c4d.bitmaps.BaseBitmap(), help="", dat=MyCommandData())
Hi,
have you tried using a non-modal dialog? I am using dialogs not very often, but it could be possible that the modal dialog blocks redraws of your scene.
dlg.Open(c4d.DLG_TYPE_ASYNC, -1, -1, 400, 200)
Sometimes you have also to invoke a redraw manually.
c4d.EventAdd(c4d.EVENT_FORCEREDRAW) or c4d.DrawViews(c4d.DRAWFLAGS_NONE)
Cannot say much else, do not have c4d here to test your code.
Cheers
zipit
You are calling the Dialog via
DLG_TYPE_MODAL. So the Dialog is blocking the main thread until you close it.
Try opening the dialog with
DLG_TYPE_ASYNC.
It was indeed the modal window that prevented the real-time display of objects.
By putting the code below, the display of objects is immediate.
class MyCommandData(c4d.plugins.CommandData):
def Execute(self, doc):
self.dlg = MyDialog()
self.dlg.Open(c4d.DLG_TYPE_ASYNC, -1, -1, 400, 200)
return True
However, the plugin window opens to the left of my screen and to move it to the center of the screen, I must first enlarge it.
I find that a little strange !
But it can be considered that my problem is solved.
Thank you for your answers
@Kantronin said in Objects created in real time:
self.dlg.Open(c4d.DLG_TYPE_ASYNC, -1, -1, 400, 200)
However, the plugin window opens to the left of my screen and to move it to the center of the screen, I must first enlarge it.
The GeDialog manual says:
If xpos=-1 and ypos=-1 the dialog will be opened at the current mouse position.
If xpos=-2 and ypos=-2 the dialog will be opened at the center of the screen.
So, if the dialog opens to the left of your screen, I guess that's where your mouse was? Try -2, .
@zipit and @Cairyn have already answer here (thanks a lot) nothing to add.
Cheers,
Manuel | https://plugincafe.maxon.net/topic/11881/objects-created-in-real-time/3 | CC-MAIN-2019-47 | en | refinedweb |
When I set out to create xdg-app I had two goals:
- Make it possible for 3rd parties to create and distribute applications that works on multiple distributions.
- Run applications with as little access as possible to the host. (For example access to the network or the users files.).
8 thoughts on “xdg-app 0.5.0 released”
Please if possible target xenial (dev) instead of vivid (EOL) for Ubuntu PPA.
Thanks!
Bryan
Its very exciting news, I have been following xdg-app development for a while, and have a basic questions:
could xdg-app be considered as a rival to docker or even replace it in future? Here we have same underlying technology, cgroup, namespaces, etc. Docker, rkt, lxc etc are here to 1) allow for portable packaging format for apps (one damn format to run everywhere) 2) sandbox apps and separate it from host. These are both goals of xdg-app!
To my mind it is just ridiculous to have a format for desktop apps and another one with exact same underlying technology for server apps! And where is the boundary between server and desktop? What if I install MySQL/bind9 etc on my desktop?
Also docker style of aggregating all app and dependencies and OS detail in one huge image is not exactly very smart! xdg-app style with runtimes is far smarter, that’s why I wish to see xdg-app on both desktop and server space! One app format for Linux.
//mehdi
Medhi: xdg-app and docker are quite different and do different things well. They share a lot of technologies, but can’t replace each other. | https://blogs.gnome.org/alexl/2016/03/17/xdg-app-0-5-0-released/ | CC-MAIN-2019-47 | en | refinedweb |
A simplified interface for your main function.
Project description
Pymain - Simplified main
Pymain is a decorator and related tools to simplify your main function(s). It is intended to be more simple to use and understand than argparse, while still providing most of the functionality of similar libraries.
Description
The basic idea of pymain is that your main function (though it doesn’t need to be called “main”), and therefore your script or application itself, probably takes parameters and keyword arguments in the form of command line arguments. Since that interface works very similar to calling a python function, pymain translates between those interfaces for you. In addition, so many scripts with entry points include the if __name__ == '__main__': boilerplate, and pymain aims to eliminate that.
Usage
Import and use the @pymain decorator before your main function that has type annotations for the parameters. If you don’t need any short options or aliases, that is all you need to do. Pymain will detect whether the defining module is run as a script (and therefore __name__ == "__main__") or if it is being imported. If it is run as a script, then main will be called and given arguments based on sys.argv. If it is imported, then pymain will not run the function as a main function and it can still be called normally.
Pymain uses the type annotations to determine what types to expect. For short options or aliases, you can add an @alias decorator after the @pymain decorator describing the alias (either a single alias or a dictionary of multiple)
All arguments that are greater than one character in length are long options (e.g. –arg), and arguments that have a single character are short options (e.g. -a). Aliases follow the same rules.
Examples
optional.py:
from pymain import pymain @pymain def main(a: float, b: float, c: str = None): print(a / b) if c is not None: print(c)
Command line:
~ $ python optional.py 4 2 2.0
~ $ python optional.py 9 2 message 4.5 message
keyword.py:
from pymain import pymain @pymain def main(first: int, second: int, *, message: str = None): print(first + second) if message is not None: print(message)
Command line:
~ $ python main.py 4 6 10
~ $ python main.py 1 2 --message "Hello, World!" 3 Hello, World!
alias.py:
from pymain import pymain, alias @pymain @alias({"opt1": "x", "opt2": "y"}) def foo(value: float, *, opt1: float = 1.0, opt2: float = 2.0): print(value + opt1) print(value - opt2)
Command line:
~ $ python alias.py 2 3.0 0.0
~ $ python alias.py 5 -x 1 -y 1 6.0 4.0
~ $ python alias.py 10 --opt1 5 --opt2 2 15.0 8.0
Project details
Release history Release notifications
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages. | https://pypi.org/project/pymain/ | CC-MAIN-2019-47 | en | refinedweb |
How to use a ESP32 development board to read temperature and humidity from a DHT22 sensor
When you have a DHT22 / AM2302 sensor, you will be able to get the temperature and humidity of your environment.
Given that, this post shows how to use ESP32 development board to read temperature and humidity from a DHT22 sensor.
Wiring your DHT22 sensor to your ESP32 development board
When you look at your DHT22 sensor, you can see three pins labeled +, out and -. Connect the:
- + pin to a 3v3 pin on your board
- out pin to GPIO27 on your board
- - pin to a GND pin on your board
Enabling ESP32 Development on Arduino IDE
At this point in time, you are ready to flash a program into your ESP32 board to read from the DHT22 sensor..
Installing the DHT sensor library for ESPx to read temperature and humidity from DHT22 sensor
After you had started your Arduino IDE, proceed to install a Arduino Library to read temperature and humidity from DHT22 sensor.
In order to do so, first go to Tools -> Manage Libraries.... After you had done so, the Library Manager window will appear. Search for DHT22 and install the DHT sensor library for ESPx by beegee_tokyo:
After you had installed the library, you will be able to write the Arduino sketch to read temperature and humidity from your DHT22 sensor.
Arduino sketch example to read temperature and humidity from the DHT22 sensor
Once you had installed the DHT sensor library for ESPx, upload the following sketch to your ESP32 board:
#include "DHTesp.h" DHTesp dht; void setup() { Serial.begin(9600); dht.setup(27, DHTesp::DHT22);:
| https://www.techcoil.com/blog/how-to-use-a-esp32-development-board-to-read-temperature-and-humidity-from-a-dht22-sensor/ | CC-MAIN-2019-47 | en | refinedweb |
Content Count287
Joined
Last visited
13 Followers
About Dreamful
- RankAdvanced Member
Recent Profile Visitors
Kamogli reacted to a file: [C#] dRotation - Shadow Priest (PvE)
Kamogli reacted to a file: Deathknight [Unholy] [PvE & PvP] [WoLTK] - Dreamful
Kamogli reacted to a file: [C#] dRotation - Marksman Hunter (PvE)
Matenia reacted to a post in a topic: Rogue Poisons/Item usage
Dreamful reacted to a post in a topic: Sick of buying garbage profiles
Dreamful reacted to a file: [Free] Bloody - A Blood DK Routine
Dreamful reacted to a file: [PAID][Product] AdvancedBattlegrounder
Dreamful reacted to a file: [PAID] [Alliance] 1 to 450 - Tailoring Profile - Fully Automated
Dreamful reacted to a file: [PAID] [Horde] 1 to 450 - Mining Profile - Fully Automated
timamusic reacted to a file: Hunter [Marksman] [Leveling 1-80] [WotLK] - Dreamful
-
- Dreamful started following wRobot predefined settings
wRobot predefined settings
Dreamful replied to Inaru's topic in Developers assistanceHey Inaru, You can use this,
Dreamful reacted to a file: [Battle Grounds] Retribution Paladin 3.3.5a
[C#] dRotation - Arcane Mage (PvE)
Dreamful commented on Dreamful's file in Fight Classes - Wotlk
[C#] dRotation - Shadow Priest (PvE)
Dreamful commented on Dreamful's file in Fight Classes - Wotlk
- Dreamful started following New and confused., Dragonblight issues ( Privat server ), Press Macro when Dead and and 1 other
anarchia reacted to a file: dDungeonAlerter - never miss an invite
saleh reacted to a post in a topic: Can't get Hunter to use Ranged Attack
Dreamful reacted to a post in a topic: C# Fightclass development - video tutorial
-
Dragonblight issues ( Privat server )
Dreamful replied to Bikinibottom's topic in General discussionCarefully with PQR on that server, the Main server "Rising-Gods" has a warden protection and bans directly. i am using this one and works perfect,
Press Macro when Dead
Dreamful replied to maukor's topic in WRobot for Wow Vanilla - Help and supportusing robotManager.Helpful; using wManager.Wow.Enums; using wManager.Wow.Helpers; using wManager.Events; using wManager.Wow.ObjectManager; using System.Media; using System.Windows.Forms; using System; using System.Threading; public class Main : wManager.Plugin.IPlugin { private bool _isRunning; /* Code here runs when the plugin is enabled and the bot it started. */ public void Initialize() { _isRunning = true; Logging.Write("[SpirithealerFixer] Loaded."); SpirithealerAccept(); } public void SpirithealerAccept() { while (_isRunning) { try { if (ObjectManager.Me.HaveBuff(8326)) { Lua.LuaDoString("StaticPopup1Button1:Click()"); } } catch (Exception e) { Logging.WriteError(" ERROR: " + e); } Thread.Sleep(10); // Pause 10 ms to reduce the CPU usage. } } public void Dispose() { _isRunning = false; Logging.Write("[SpirithealerFixer] Stopped."); } public void Settings() { Logging.Write("[SpirithealerFixer] No settings."); } } I have the problem the Spirithealer rezzing is till today not working on Woltk, i made a plugin that spams the Accept button all day long if you have a dead debuff. i dont know if that works, but just change it for the dead buff in vanilla and you good to go. Hope i understand your usage correctly. Peace, Dreamful
Dreamful reacted to a file: [Free] TBC Hunter 1-70 Leveling FC + Feed Pet + Auto Cheetah
Routing WoW Through Multiple VPN's on Same Machine
Dreamful replied to johnblaster123's topic in Tutorials - WRobotVirtual machine software is designed to mimic the hardware functionality of real hardware. But when doing so, some artifacts remain, which help indicate that it is indeed a virtual machine and not a physical one. These kind of artifacts can be specific files, processes, registry keys, services, network device adapters etc. Malware programmers take advantage of this “design flaw”. They code the malware to detect virtual machine configuration files, executables, registry entries or other indicators in order to manipulate their original execution flow. This behavior is referred to as “Anti-Sandbox” or “Anti-VM”. So if a registry entry like SYSTEM\CurrentControlSet\Control\VirtualDeviceDrivers exist or even a running process like Vmtoolsd.exe, Vmwaretrat.exe, you get flagged. Start your virtual machine and inside you will see in the taskmgr there will be processes that not running on your system. This is just all speculation, i dont know how warden works in depth, but the cases you see above can be used for a flag.
Routing WoW Through Multiple VPN's on Same Machine
Dreamful replied to johnblaster123's topic in Tutorials - WRobotWhat you're up to won't work, because that's not the point of a VPN. What you are looking for is a Socks5 together with Proxifier. You can tunnel all traffic program specific with it. NordVPN also sells Socks5 proxy or given even away if you have a subsciption, if I'm not mistaken.
Dreamful reacted to a post in a topic: Cannot sign up, pls help.
[C#] dRotation - Mutilate Rogue (PvE)
Dreamful commented on Dreamful's file in Fight Classes - Wotlk
Osama reacted to a file: [C#] dRotation - Mutilate Rogue (PvE)
[C#] dRotation - Mutilate Rogue (PvE)
Dreamful commented on Dreamful's file in Fight Classes - Wotlk
klunz reacted to a post in a topic: New and confused.
New and confused.
Dreamful replied to klunz's topic in WRobot for Wow Legion - Help and supporti would say wRobot is more like a framework, there are many free profiles, some are good, some rather not. There are also paid ones but even those are not bug free and 100% quester like you know from honorbuddy. Keep in mind private servers differ, some quest work on servers others don't. You will not have a 100% bugfree and fully afkable profile. And especially since you will come to a point where you have to make yourself one because there are none.
- I was able to test the profile in advance, runs through without any problems. He kills all mobs in the instance as well as bosses and goes out again resets instance until your inventory is full and goes for selling. Kinda good gear is required or a Tank spec like Blood DK, Prot Paladin, Feral Tank, otherwise you need to regen between pulls and losing time, losing time equals losing gold.
- Probaly one of the best and true quest profile here on wRobot and not some bullshit like only do 50 quests the whole leveling from 1 - 60 and rest is pure grinding. i already leveld a Troll Mage till 50 with this profile and had no stucks or hickups, paired with a good fightclass you can safe run this 100% AFKable.
[C#] dRotation - Marksman Hunter (PvE)
Dreamful commented on Dreamful's file in Fight Classes - Wotlk
- Bambo asked me if i can test this profile before release, tested it on Wotlk and worked flawless. No stucks, bugs, like butter. Did multiple runs with a level 80 Deathknight. You can actually really do good gold from that, On average you get one Assasin’s Blade of every 85 SFK runs (Blizzlike drop rate) that sells for 500+ Gold on a Classic server depending of demand of course. Valuable Items as example that can drop, Assassin's Blade Shadowfang Night Reaver Witching Stave Black Malice Guillotine Axe I already have his 1-70 Alliance Grinder and he puts much effort in his profiles, if something not works quite like it should be he answers you in Discord quick and next update its fixed. And for testing this profile i got it for free, what was very nice of him. Looking forward for more Dungeon Farming profiles.
[C#] dRotation - Marksman Hunter (PvE)
Dreamful commented on Dreamful's file in Fight Classes - Wotlk | https://wrobot.eu/profile/28878-dreamful/ | CC-MAIN-2019-47 | en | refinedweb |
Services resource. If you don't have an account, you can use the free trial to get a subscription key.
Prerequisites
This quickstart requires:
- Python 2.7.x or 3.x
- Visual Studio, Visual Studio Code, or your favorite text editor
- An Azure subscription key for the Speech Services
Create a project and import required modules
Create a new Python project using your favorite IDE or editor. Then copy this code snippet into your project in a file named
tts.py.
import os import requests import time from xml.etree import ElementTree
Note
If you haven't used these modules you'll need to install them before running your program. To install these packages, run:
pip install requests.
These modules are used to write the speech response to a file with a timestamp, construct the HTTP request, and call the text-to-speech API.
Set the subscription key and create a prompt for TTS
In the next few sections you'll create methods to handle authorization, call the text-to-speech API, and validate the response. Let's start by adding some code that makes sure this sample will work with Python 2.7.x and 3.x.
try: input = raw_input except NameError: pass
Next, let's create a class. This is where we'll put our methods for token exchange, and calling the text-to-speech API.
class TextToSpeech(object): def __init__(self, subscription_key): self.subscription_key = subscription_key self.tts = input("What would you like to convert to speech: ") self.timestr = time.strftime("%Y%m%d-%H%M") self.access_token = None
The
subscription_key is your unique key from the Azure portal.
tts prompts the user to enter text that will be converted to speech. This input is a string literal, so characters don't need to be escaped. Finally,
timestr gets the current time, which we'll use to name your file.
Get an access token
The text-to-speech REST API requires an access token for authentication. To get an access token, an exchange is required. This sample exchanges your Speech Services subscription key for an access token using the
issueToken endpoint.
This sample assumes that your Speech Services subscription is in the West US region. If you're using a different region, update the value for
fetch_token_url. For a full list, see Regions.
Copy this code into the
TextToSpeech class:
def get_token(self): fetch_token_url = "" headers = { 'Ocp-Apim-Subscription-Key': self.subscription_key } response = requests.post(fetch_token_url, headers=headers) self.access_token = str(response.text)
Note
For more information on authentication, see Authenticate with an access token.
Make a request and save the response
Here you're going to build the request and save the speech response. First, you need to set the
base_url and
path. This sample assumes you're using the West US endpoint. If your resource is registered to a different region, make sure you update the
base_url. For more information, see Speech Services regions.
Next, you need to add required headers for the request. Make sure that you update
User-Agent with the name of your resource (located in the Azure portal), and set
X-Microsoft-OutputFormat to your preferred audio output. For a full list of output formats, see Audio outputs.
Then construct the request body using Speech Synthesis Markup Language (SSML). This sample defines the structure, and uses the
tts input you created earlier.
Note
This sample uses the
Guy24KRUS voice font. For a complete list of Microsoft provided voices/languages, see Language support.
If you're interested in creating a unique, recognizable voice for your brand, see Creating custom voice fonts.
Finally, you'll make a request to the service. If the request is successful, and a 200 status code is returned, the speech response is written to a timestamped file.
Copy this code into the
TextToSpeech class:
def save_audio(self): base_url = '' path = 'cognitiveservices/v1' constructed_url = base_url + path headers = { 'Authorization': 'Bearer ' + self.access_token, 'Content-Type': 'application/ssml+xml', 'X-Microsoft-OutputFormat': 'riff-24khz-16bit-mono-pcm', 'User-Agent': 'YOUR_RESOURCE_NAME' } xml_body = ElementTree.Element('speak', version='1.0') xml_body.set('{}lang', 'en-us') voice = ElementTree.SubElement(xml_body, 'voice') voice.set('{}lang', 'en-US') voice.set( 'name', 'Microsoft Server Speech Text to Speech Voice (en-US, Guy24KRUS)') voice.text = self.tts body = ElementTree.tostring(xml_body) response = requests.post(constructed_url, headers=headers, data=body) if response.status_code == 200: with open('sample-' + self.timestr + '.wav', 'wb') as audio: audio.write(response.content) print("\nStatus code: " + str(response.status_code) + "\nYour TTS is ready for playback.\n") else: print("\nStatus code: " + str(response.status_code) + "\nSomething went wrong. Check your subscription key and headers.\n")
Put it all together
You're almost done. The last step is to instantiate your class and call your functions.
if __name__ == "__main__": subscription_key = "YOUR_KEY_HERE" app = TextToSpeech(subscription_key) app.get_token() app.save_audio()
Run the sample app
That's it, you're ready to run your text-to-speech sample app. From the command line (or terminal session), navigate to your project directory and run:
python tts.py
When prompted, type in whatever you'd like to convert from text-to-speech. If successful, the speech file is located in your project folder. Play it using your favorite media player.
Clean up resources
Make sure to remove any confidential information from your sample app's source code, like subscription keys.
Next steps
See also
Feedback | https://docs.microsoft.com/en-us/azure/cognitive-services/speech-service/quickstart-python-text-to-speech | CC-MAIN-2019-47 | en | refinedweb |
24479/derivative-of-manipulated-spline
import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import InterpolatedUnivariateSpline
x = np.arange(1, 9)
y = np.sqrt(x) # something to use as y-values
spl = InterpolatedUnivariateSpline(x, y)
logder = lambda x: spl.derivative()(x)/spl(x) # derivative of log of spline
t = np.linspace(x.min(), x.max())
plt.plot(t, logder(t))
plt.show()
Constructing a spline based on the logarithm of data is also a reasonable approach, but it is not the same thing as the logarithm of the original spline.
if you can define a function, depending on a spline, which can be differentiated by python (analytically)
if you can define a function, depending on a spline, which can be differentiated by python (analytically)
Differentiating an arbitrary function analytically is out of scope for SciPy. In the above example, I had to know that the derivative of log(x) is 1/x; SciPy does not know that. SymPy is a library for symbolic math operations such as derivatives.
It's possible to use SymPy to find the derivative of a function symbolically and then turn it, using lambdify, into a callable function that SciPy or matplotlib, etc can use.
One can also work with splines in an entirely symbolic way using SymPy but it's slow.
Polymorphism is the ability to present the ...READ MORE
The break statement is used to "break" ...READ MORE
There are several options. Here is a ...READ MORE
To count the number of appearances:
from collections ...READ MORE
suppose you have a string with a ...READ MORE
if you google it you can find. ...READ MORE
Syntax :
list. count(value)
Code:
colors = ['red', 'green', ...READ MORE
can you give an example using a ...READ MORE
FlyingTeller's suggestion is probably optimal: the derivative of ...READ MORE
Use the following query statement and let ...READ MORE
OR
Already have an account? Sign in. | https://www.edureka.co/community/24479/derivative-of-manipulated-spline | CC-MAIN-2019-47 | en | refinedweb |
Volume finite element with switches. More...
#include <src/finite_elements/VolumeElementForcesAndSourcesCore.hpp>
Volume finite element with switches.
Using SWITCH to off functions
Definition at line 337 of file VolumeElementForcesAndSourcesCore.hpp.
Definition at line 343 of file VolumeElementForcesAndSourcesCore.hpp.
function is run for every finite element
It is used to calculate element local matrices and assembly. It can be used for post-processing.
Reimplemented from MoFEM::ForcesAndSourcesCore.
Reimplemented in MoFEM::VolumeElementForcesAndSourcesCoreOnSideSwitch< SWITCH >.
Definition at line 388 of file VolumeElementForcesAndSourcesCore.hpp. | http://mofem.eng.gla.ac.uk/mofem/html/struct_mo_f_e_m_1_1_volume_element_forces_and_sources_core_switch.html | CC-MAIN-2020-05 | en | refinedweb |
Lambda Expressions and Method References
Lambda Expressions and Method References
In this article, we discuss how to use lamdba expressions and reference methods in Java 8 in order to keep code size at a minimum.
Join the DZone community and get the full member experience.Join For Free
Hello, friends this my first article on Java 8.
Today, I am going to share how lambda expressions and method references reduce boilerplate code and make our code more readable and compact. Suppose we have a
Student class that has two fields,
name and
age. We are going to sort a student list with the help of the
Comparator interface. After that, we will reduce the code step-by-step with the help of some of Java 8's new features.
This is our
Student class, with their two fields and getter and setter methods. We are overriding the
toString method of the
Object class.
xxxxxxxxxx
class Student {
private String name;
private Integer age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
Suppose we have
studentlist that we are going to sort. We know that
List provides a
sort method and
signature like:
xxxxxxxxxx
void sort(Comparator<? super E> c)
It expects a
Comparator object as an argument to compare two
Students!
You may also like: Functional Programming Patterns With Java 8.
Step 1: Create Custom StudentComparator to Pass Into the Sort Method
The solution looks like this:
xxxxxxxxxx
public class StudentComparator implements Comparator<Student> {
public int compare(Student s1, Student s2){
return s1.getAge().compareTo(s2.getAge());
}
}
studentlist.sort(new StudentComparator());
Step 2: Use an Anonymous Class
Rather than implementing
Comparator for the purpose of instantiating it once, we could use an anonymous class to improve our solution. The solution looks like this:
xxxxxxxxxx
studentlist.sort(new Comparator<Student>(){
public int compare(Student s1, Student s2){
return s1.getAge().compareTo(s2.getAge());
}
});
Step 3: Use Lambda Expressions
Our current solution is still verbose. Java 8 introduces lambda expressions, which provide a lightweight syntax to achieve the same goal.
We know that lambda expression can be used where a functional interface is expected: a functional interface is an interface defining only one abstract method.
The signature of the abstract method (called function descriptor) can describe the signature of a lambda expression. In our case, the
Comparator represents a function descriptor
(T, T) -> int.
Because we’re using
Student, it represents more specifically,
(Student, Student) -> int. Our improved solution looks like the following code snippet:
xxxxxxxxxx
studentlist.sort((Student std1, Student std2) -> std1.getAge().compareTo(std2.getAge()));
We can write our solution like this:
xxxxxxxxxx
studentlist.sort((std1, std2) -> std1.getAge().compareTo(std2.getAge()));
Java's compiler could infer the types of the parameters of a lambda expression by using the context in which the lambda appears. So, we can avoid the use of types of parameters.
Can we make our code even more readable? Yes,
Comparator has a static helper method called,
comparing, that takes a function extracting a
Comparable key and produces a
Comparator object.
We can now rewrite our solution in a slightly more compact form:
xxxxxxxxxx
import static java.util.Comparator.comparing;
studentlist.sort(comparing((std) -> std.getAge()));
Step 4: Use Method References
We can use a method reference to make our code slightly less verbose:
xxxxxxxxxx
static import of java.util.Comparator.comparing
studentlist.sort(comparing(Student::getAge));
Congratulations, this is our final solution!
It’s shorter; it’s also obvious what it means, “sort Student comparing the age of the Student.” This is how Java 8 makes code more readable and compact.
If you have any doubts, feel free to ask me in the comment section below. Have a nice day.
Reference: Java 8 in Action.
Further Reading
Opinions expressed by DZone contributors are their own.
{{ parent.title || parent.header.title}}
{{ parent.tldr }}
{{ parent.linkDescription }}{{ parent.urlSource.name }} | https://dzone.com/articles/lamda-expression | CC-MAIN-2020-05 | en | refinedweb |
of querying
/usersto get a list of users, or
/user/:idto get a particular user, the endpoint will look like
/graphqlfor all the requests.
- In GraphQL, the data coming back from a response is set by the query library stated and it can be set to only send a few data properties, therefore, queries in GraphQL have better performance.
- No need to set method verbs in GraphQL. Keywords such as Query or Mutation will decide what the request will perform.
- REST API routes usually are handled by one route handler. In GraphQL you can have a single query trigger multiple mutations and get a compound response from multiple sources.
Queries
A query is a GraphQL method that allows us to GET data from our API. Even though it may receive parameters to filter, order, or simply search for a particular document a query can not mutate this data.
Mutations
Mutations are everything that is not what would refer to a GET verb in regular APIs. Updating, creating, or deleting data from our API is done via mutations
Subscriptions
With the use of web sockets, a subscription refers to a connection between the client and the server.
The server is constantly watching for mutations or queries that are attached to a particular subscription, and communicate any changes to the client in real time. Subscriptions are mostly used for real-time widgets/apps.
Types and Inputs
To make sure our queries and mutations can process the data to query a database,
types work much like a model ORM for databases. By setting types up we can define the type of variable our resolvers will return.
Similarly, we need to set input types for our resolvers to receive.
For example, we will define a couple
types and
inputs:
type User { id: ID name: String! age: Int! address: Address followers: [ID] } type Address { street: String city: String country: String } input UserInput { name: String! age: Int! } type Query { getAllUsers: [User] } type Mutation { createUser(user: UserInput!): ID }
Properties can have a custom type as its type apart from the primitive ones, such as:
- String
- Int
- Float
- Boolean
- ID
And they can also be an array of a certain type determined by the brackets, which is shown in the example above.
Furthermore, the mandatory status of a property can be set with the
!, meaning that the property needs to be present.
Resolvers
These are the actions that are performed when calling queries and mutations.
getAllUsers and
createUser are going to be connected to a resolver that will perform the actual calculations and database queries.
Creating our Project
For this tutorial, we will be creating a Vue.js project using the Vue CLI 3.0, which will bootstrap a project with a folder structure that looks like this:
If you need help setting up the project, you can look at this tutorial for the command line interface.
We can start serving our application with the command:
$ npm run serve
Apollo Client
Apollo Client brings a tool to front-end development to make GraphQL queries/mutations easier. It acts as an HTTP client that connects to a GraphQL API and provides caching, error handling, and even state management capabilities.
For this tutorial, Vue-Apollo will be used, which is the Apollo integration specially designed for Vue.js.
Apollo Configuration
To start our Apollo configuration a few packages will need to be installed:
$ npm install apollo-client apollo-link-http apollo-cache-inmemory vue-apollo graphql graphql-tag
Inside a
/graphql folder in our project, we will create
apollo.js:
// apollo.js import Vue from 'vue' import { ApolloClient } from 'apollo-client' import { HttpLink } from 'apollo-link-http' import { InMemoryCache } from 'apollo-cache-inmemory' import VueApollo from 'vue-apollo' const httpLink = new HttpLink({ uri: process.env.VUE_APP_GRAPHQL_ENDPOINT }) // Create the apollo client export const apolloClient = new ApolloClient({ link: httpLink, cache: new InMemoryCache(), connectToDevTools: true }) // Install the Vue plugin Vue.use(VueApollo) export const apolloProvider = new VueApollo({ defaultClient: apolloClient })
HttpLink is an object that requires a
uri property, which refers to the GraphQL endpoint from the API being used. Ex:
localhost:8081/graphql
Then, a new
ApolloClient instance needs to be created, where the link, cache instance, and further options can be set.
Finally, we wrap our
ApolloClient inside a
VueApollo instance so we can use its hooks inside our Vue components.
Global Error Handling
There is a way of handling errors globally inside the configuration file. For that we need to install an npm package called
apollo-link-error, which inspects and manages errors from the network:
// apollo.js import Vue from 'vue' import { ApolloClient } from 'apollo-client' import { HttpLink } from 'apollo-link-http' import { onError } from "apollo-link-error" import { InMemoryCache } from 'apollo-cache-inmemory' import VueApollo from 'vue-apollo' const httpLink = new HttpLink({ uri: process.env.VUE_APP_GRAPHQL_ENDPOINT }) // Error Handling const errorLink = onError(({ graphQLErrors, networkError }) => { if (graphQLErrors) graphQLErrors.map(({ message, locations, path }) => console.log( `[GraphQL error]: Message: ${message}, Location: ${locations}, Path: ${path}` ) ) if (networkError) console.log(`[Network error]: ${networkError}`) }) // Create the apollo client export const apolloClient = new ApolloClient({ link: errorLink.concat(httpLink), cache: new InMemoryCache(), connectToDevTools: true }) // Install the Vue plugin Vue.use(VueApollo) export const apolloProvider = new VueApollo({ defaultClient: apolloClient })
After importing the
onError function from the package, we can implement it as a sort of middleware of Apollo Client. It'll catch any network or GraphQL errors, giving us the chance to manage them globally.
The callback gets called with an object with some properties whenever an error has happened:
- operation: The operation that triggered the callback because an error was found.
- response: The result of the operation.
- graphQLErrors: An array of errors from the GraphQL endpoint
- networkError: Any error during the execution of the operation or server error.
- forward: The next link referenced in the chain.
Managing State with Apollo Client
A different alternative to using Vuex with Vue projects, and when using the Apollo Client is to use a package called
apollo-link-state.
It works as a local data management tool that works as if you were querying a server, but it does it locally.
Also, it is a great way of managing the cache for our application, thus making Apollo Client an HTTP client and state/cache management tool.
For more information, you can check the official documentation for Apollo-link-state.
Creating Queries
For creating queries we need to set up a string-type tag with the package graphql-tag. For keeping a tidy and structured project, we will create a folder called
queries inside the graphql folder.
Assuming the server receiving the query is set up properly to interpret this query, for example, we can trigger a resolver called
getAllUsers:
import gql from 'graphql-tag' export const GET_ALL_USERS_QUERY = gql` query getAllUsers { getAllUsers { // Fields to retrieve name age } } `
The default operation in GraphQL is
query, so the
query keyword is optional.
If a retrieved field has subfields, then at least one of them should be fetched for the query to succeed.
Using Mutations
Much like queries, we can also use mutations by creating a
gql-string.
import gql from 'graphql-tag' export const CREATE_USER_MUTATION = gql` mutation createUser($user: UserInput!) { createUser(user: $user) } `
Our
createUser mutation expects a
UserInput input, and, to be able to use parameters passed by Apollo. We will first define a variable with the
$ called
user. Then, the outside wrapper will pass the variable to the
createUser mutation, as expected by the server.
Fragments
In order to keep our
gql-type strings tidy and readable, we can use fragments to reuse query logic.
fragment UserFragment on User { name: String! age: Int! } query getAllUsers { getAllUsers { ...UserFragment } }
Using GraphQL in Vue components
Inside the
main.js file, to configure the Apollo Client, we need to import and attach the client to our instance.
// main.js import Vue from 'vue' import { apolloProvider } from './graphql/apollo' Vue.config.productionTip = false /* eslint-disable no-new */ new Vue({ el: '#app', apolloProvider, render: h => h(App) })
Since we have added our ApolloProvider to the Vue instance, we can access the client through the
$apollo keyword:
// GraphQLTest.vue <template> <div class="graphql-test"> <h3 v-Loading...</h3> <h4 v-{{ getAllUsers }}</h4> </div> </template> <script> import { GET_ALL_USERS_QUERY } from '../graphl/queries/userQueries' export default { name: 'GraphQLTest', data () { return { users: [] } }, async mounted () { this.loading = true this.users = await this.$apollo.query({ query: GET_ALL_USERS_QUERY }) this.loading = false } } </script>
If we want to create a user, we can use a
mutation:
// GraphQLTest.vue <template> <div class="graphql-test"> <input v- <input v- <button @Create User</button> </div> </template> <script> import { CREATE_USER_MUTATION } from '../graphl/queries/userQueries' export default { name: 'GraphQLTest', data() { return { user: { name: null, age: null } } }, methods: { async createUser () { const userCreated = await this.$apollo.mutate({ mutation: CREATE_USER_MUTATION, variables: { user: this.user // this should be the same name as the one the server is expecting } }) // We log the created user ID console.log(userCreated.data.createUser) } } } </script>
Using this approach lets us micro-manage when and where our mutations and queries will execute. Now we will see some other ways of handling these methods that Vue Apollo gives us.
The Apollo Object
Inside our Vue components, we get access to the
Apollo object, which can be used to easily manage our queries and subscriptions:
<template> <div class="graphql-test"> {{ getAllUsers }} </div> </template> <script> import { GET_ALL_USERS_QUERY } from '../graphl/queries/userQueries' export default { name: 'GraphQL-Test', apollo: { getAllUsers: { query: GET_ALL_USERS_QUERY } } } </script>
Refetching Queries
When defining a query inside the Apollo object, it is possible to refetch this query when calling a mutation or another query with the
refetch method or the
refetchQueries property:
<template> <div class="graphql-test"> {{ getAllUsers }} </div> </template> <script> import { GET_ALL_USERS_QUERY, CREATE_USER_MUTATION } from '../graphl/queries/userQueries' export default { name: 'GraphQL-Test', apollo: { getAllUsers: { query: GET_ALL_USERS_QUERY } }, methods: { refetch () { this.$apollo.queries.getAllUsers.refetch() }, queryUsers () { const user = { name: Lucas, age: 26 } this.$apollo.mutate({ mutation: CREATE_USER_MUTATION, variables: { user } refetchQueries: [ { query: GET_ALL_USERS_QUERY } ] }) } } } </script>
By using the
Apollo object, provided to us by Vue-Apollo, we no longer need to actively use the Apollo client way of triggering queries/subscriptions and some useful properties and options become available to us.
Apollo Object Properties
- query: This is the
gqltype string referring to the query that wants to get triggered.
- variables: An object that accepts the parameters being passed to a given query.
- fetchPolicy: A property that sets the way the query will interact with the cache. The options are
cache-and-network,
network-only,
cache-only,
no-cache,
standbyand the default is
cache-first.
- pollInterval: Time in milliseconds that determines how often a query will automatically trigger.
Special Options
- $error to catch errors in a set handler.
- $deep watches deeply for changes in a query.
- $skip: disables all queries and subscriptions in a given component.
- $skipAllQueries: disables all queries from a component.
- $skipAllSubscriptions: to disables all subscriptions in a component.
Apollo Components
Inspired by the way the Apollo Client is implemented for React (React-Apollo), Vue-Apollo provides us with a few components that we can use out of the box to manage the UI and state of our queries and mutations with a Vue component inside the template.
ApolloQuery
Simpler way of managing our queries in a more intuitive manner:
<ApolloQuery : <template slot- <!-- Loading --> <div v-Query is loading.</div> <!-- Error --> <div v-We got an error!</div> <!-- Result --> <div v-{{ data.getAllUsers }}</div> <!-- No result (if the query succeed but there's no data) --> <div v-else>No result from the server</div> </template> </ApolloQuery>
ApolloMutation
Very similar to the example above, but we must trigger the mutation with the
mutate function call:
<ApolloMutation : <template slot- <!-- Loading --> <h4 v-The mutation is loading!</h4> <!-- Mutation Trigger --> <button @Create User</button> <!-- Error --> <p v-An error has occurred!</p> </template> </ApolloMutation>
Conclusion
GraphQL brings a lot of flexibility to API development, from performance, ease-of-use, and an overall different perspective of what an API should look and behave like. Furthermore, ApolloClient and Vue Apollo delivers a set of tools for better management of our UI, state and operations, even error handling and cache!
For more information about GraphQL and Apollo Client you can visit the following: | https://stackabuse.com/building-graphql-apis-with-vue-js-and-apollo-client/ | CC-MAIN-2020-05 | en | refinedweb |
Introduction.
Defining Terms
To begin with, let's start by defining our terms. It may prove difficult to understand why certain lines of code are being executed unless you have a decent understanding of the concepts that are being brought together.
TensorFlow
TensorFlow is one of the most commonly used machine learning libraries in Python, specializing in the creation of deep neural networks. Deep neural networks excel at tasks like image recognition and recognizing patterns in speech. TensorFlow was designed by Google Brain, and its power lies in its ability to join together many different processing nodes.
Keras
Meanwhile, Keras is an application programming interface or API. Keras makes use of TensorFlow's functions and abilities, but it streamlines the implementation of TensorFlow functions, making building a neural network much simpler and easier. Keras' foundational principles are modularity and user-friendliness, meaning that while Keras is quite powerful, it is easy to use and scale.
Natural Language Processing
Natural Language Processing (NLP) is exactly what it sounds like, the techniques used to enable computers to understand natural human language, rather than having to interface with people through programming languages. Natural language processing is necessary for tasks like the classification of word documents or the creation of a chatbot.
Corpus
A corpus is a large collection of text, and in the machine learning sense a corpus can be thought of as your model's input data. The corpus contains the text you want the model to learn about.
It is common to divide a large corpus into training and testing sets, using most of the corpus to train the model on and some unseen part of the corpus to test the model on, although the testing set can be an entirely different set of data. The corpus typically requires preprocessing to become fit for usage in a machine learning system.
Encoding
Encoding is sometimes referred to as word representation and it refers to the process of converting text data into a form that a machine learning model can understand. Neural networks cannot work with raw text data, the characters/words must be transformed into a series of numbers the network can interpret.
The actual process of converting words into number vectors is referred to as "tokenization", because you obtain tokens that represent the actual words. There are multiple ways to encode words as number values. The primary methods of encoding are one-hot encoding and creating densely embedded vectors.
We'll go into the difference between these methods in the theory section below.
Recurrent Neural Network
A basic neural network links together a series of neurons or nodes, each of which take some input data and transform that data with some chosen mathematical function. In a basic neural network, the data has to be a fixed size, and at any given layer in the neural network the data being passed in is simply the outputs of the previous layer in the network, which are then transformed by the weights for that layer.
In contrast, a Recurrent Neural Network differs from a "vanilla" neural network thanks to its ability to remember prior inputs from previous layers in the neural network.
To put that another way, the outputs of layers in a Recurrent Neural Network aren't influenced only by the weights and the output of the previous layer like in a regular neural network, but they are also influenced by the "context" so far, which is derived from prior inputs and outputs.
Recurrent Neural Networks are useful for text processing because of their ability to remember the different parts of a series of inputs, which means that they can take the previous parts of a sentence into account to interpret context.
Long Short-Term Memory
Long Short-Term Memory (LSTMs) networks are a specific type of Recurrent Neural Networks. LSTMs have advantages over other recurrent neural networks. While recurrent neural networks can usually remember previous words in a sentence, their ability to preserve the context of earlier inputs degrades over time.
The longer the input series is, the more the network "forgets". Irrelevant data is accumulated over time and it blocks out the relevant data needed for the network to make accurate predictions about the pattern of the text. This is referred to as the vanishing gradient problem.
You don't need to understand the algorithms that deal with the vanishing gradient problem (although you can read more about it here), but know that an LSTM can deal with this problem by selectively "forgetting" information deemed nonessential to the task at hand. By suppressing nonessential information, the LSTM is able to focus on only the information that genuinely matters, taking care of the vanishing gradient problem. This makes LSTMs more robust when handling long strings of text.
Text Generation Theory/Approach
Encoding Revisited
One-Hot Encoding
As previously mentioned, there are two main ways of encoding text data. One method is referred to as one-hot encoding, while the other method is called word embedding.
The process of one-hot encoding refers to a method of representing text as a series of ones and zeroes. A vector containing all possible words you are interested in, often all the words in the corpus, is created and a single word is represented by a "one" value in its respective position. Meanwhile all other positions (all the other possible words) are given a zero value. A vector like this is created for every word in the feature set, and when the vectors are joined together the result is a matrix containing binary representations of all the feature words.
Here's another way to think about this: any given word is represented by a vector of ones and zeroes, with a one value at a unique position. The vector is essentially concerned with answering the question: "Is this the target word?" If the word in the list of feature words is the target a positive value (one) is entered there, and in all other cases the word isn't the target, so a zero is entered. Therefore, you have a vector that represents just the target word. This is done for every word in the list of features.
One-hot encodings are useful when you need to need to create a bag of words, or a representation of words that takes their frequency of occurrence into account. Bag of words models are useful because although they are simple models, they still maintain a lot of important information and are versatile enough to be used for many different NLP related tasks.
One drawback to using one-hot encodings is that they cannot represent the meaning of a word, nor can they easily detect similarities between words. If meaning and similarity are concerns, word embeddings are often used instead.
Word Embeddings
Word embedding refers to representing words or phrases as a vector of real numbers, much like one-hot encoding does. However, a word embedding can use more numbers than simply ones and zeros, and therefore it can form more complex representations. For instance, the vector that represents a word can now be comprised of decimal values like 0.5. These representations can store important information about words, like relationship to other words, their morphology, their context, etc.
Word embeddings have fewer dimensions than one-hot encoded vectors do, which forces the model to represent similar words with similar vectors. Each word vector in a word embedding is a representation in a different dimension of the matrix, and the distance between the vectors can be used to represent their relationship. Word embeddings can generalize because semantically similar words have similar vectors. The word vectors occupy a similar region of the matrix, which helps capture context and semantics.
In general, one-hot vectors are high-dimensional but sparse and simple, while word embeddings are low dimensional but dense and complex.
Word-Level Generation vs Character-Level Generation
There are two ways to tackle a natural language processing task like text generation. You can analyze the data and make predictions about it at the level of the words in the corpus or at the level of the individual characters. Both character-level generation and word-level generation have their advantages and disadvantages.
In general, word-level language models tend to display higher accuracy than character-level language models. This is because they can form shorter representations of sentences and preserve the context between words easier than character-level language models. However, large corpuses are needed to sufficiently train word-level language models, and one-hot encoding isn't very feasible for word level models.
In contrast, character-level language models are often quicker to train, requiring less memory and having faster inference than word-based models. This is because the "vocabulary" (the number of training features) for the model is likely to be much smaller overall, limited to some hundreds of characters rather than hundreds of thousands of words.
Character-based models also perform well when translating words between languages because they capture the characters which make up words, rather than trying to capture the semantic qualities of words. We'll be using a character-level model here, in part because of its simplicity and fast inference.
Using an RNN/LSTM
When it comes to implementing an LSTM in Keras, the process is similar to implementing other neural networks created with the sequential model. You start by declaring the type of model structure you are going to use, and then add layers to the model one at a time. LSTM layers are readily accessible to us in Keras, we just have to import the layers and then add them with
model.add.
In between the primary layers of the LSTM, we will use layers of dropout, which helps prevent the issue of overfitting. Finally, the last layer in the network will be a densely connected layer that will use a sigmoid activation function and output probabilities.
Sequences and Features
It is important to understand how we will be handling our input data for our model. We will be dividing the input words into chunks and sending these chunks through the model one at a time.
The features for our model are simply the words we are interested in analyzing, as represented with the bag of words. The chunks that we divide the corpus into are going to be sequences of words, and you can think of every sequence as an individual training instance/example in a traditional machine learning task.
Implementing an LSTM for Text Generation
Now we'll be implementing a LSTM and doing text generation with it. First, we'll need to get some text data and preprocess the data. After that, we'll create the LSTM model and train it on the data. Finally, we'll evaluate the network.
For the text generation, we want our model to learn probabilities about what character will come next, when given a starting (random) character. We will then chain these probabilities together to create an output of many characters. We first need to convert our input text to numbers and then train the model on sequences of these numbers.
Let's start out by importing all the libraries we're going to use. We need
numpy to transform our input data into arrays our network can use, and we'll obviously be using several functions from Keras.
We'll also need to use some functions from the Natural Language Toolkit (NLTK) to preprocess our text and get it ready to train on. Finally, we'll need the
sys library to handle the printing of our text:
import numpy import sys
To start off with, we need to have data to train our model on. You can use any text file you'd like for this, but we'll be using part of Mary Shelley's Frankenstein, which is available for download at Project Gutenburg, which hosts public domain texts.
We'll be training the network on the text from the first 9 chapters:
file = open("frankenstein-2.txt").read()
Let's start by loading in our text data and doing some preprocessing of the data. We're going to need to apply some transformations to the text so everything is standardized and our model can work with it.
We're going to lowercase everything so and not worry about capitalization in this example. We're also going to use NLTK to make tokens out of the words in the input file. Let's create an instance of the tokenizer and use it on our input file.
Finally, we're going to filter our list of tokens and only keep the tokens that aren't in a list of Stop Words, or common words that provide little information about the sentence in question. We'll do this by using
lambda to make a quick throwaway function and only assign the words to our variable if they aren't in a list of Stop Words provided by NLTK.
Let's create a function to handle all that:
def tokenize_words(input): # lowercase everything to standardize it input = input.lower() # instantiate the tokenizer tokenizer = RegexpTokenizer(r'\w+') tokens = tokenizer.tokenize(input) # if the created token isn't in the stop words, make it part of "filtered" filtered = filter(lambda token: token not in stopwords.words('english'), tokens) return " ".join(filtered)
Now we call the function on our file:
# preprocess the input data, make tokens processed_inputs = tokenize_words(file)
A neural network works with numbers, not text characters. So well need to convert the characters in our input to numbers. We'll sort the list of the set of all characters that appear in our input text, then use the
enumerate function to get numbers which represent the characters. We then create a dictionary that stores the keys and values, or the characters and the numbers that represent them:
chars = sorted(list(set(processed_inputs))) char_to_num = dict((c, i) for i, c in enumerate(chars))
We need the total length of our inputs and total length of our set of characters for later data prep, so we'll store these in a variable. Just so we get an idea of if our process of converting words to characters has worked thus far, let's print the length of our variables:
input_len = len(processed_inputs) vocab_len = len(chars) print ("Total number of characters:", input_len) print ("Total vocab:", vocab_len)
Here's the output:
Total number of characters: 100581 Total vocab: 42
Now that we've transformed the data into the form it needs to be in, we can begin making a dataset out of it, which we'll feed into our network. We need to define how long we want an individual sequence (one complete mapping of inputs characters as integers) to be. We'll set a length of 100 for now, and declare empty lists to store our input and output data:
seq_length = 100 x_data = [] y_data = []
Now we need to go through the entire list of inputs and convert the characters to numbers. We'll do this with a
for loop. This will create a bunch of sequences where each sequence starts with the next character in the input data, beginning with the first character:
# loop through inputs, start at the beginning and go until we hit # the final character we can create a sequence out of for i in range(0, input_len - seq_length, 1): # Define input and output sequences # Input is the current character plus desired sequence length in_seq = processed_inputs[i:i + seq_length] # Out sequence is the initial character plus total sequence length out_seq = processed_inputs[i + seq_length] # We now convert list of characters to integers based on # previously and add the values to our lists x_data.append([char_to_num[char] for char in in_seq]) y_data.append(char_to_num[out_seq])
Now we have our input sequences of characters and our output, which is the character that should come after the sequence ends. We now have our training data features and labels, stored as
x_data and
y_data. Let's save our total number of sequences and check to see how many total input sequences we have:
n_patterns = len(x_data) print ("Total Patterns:", n_patterns)
Here's the output:
Total Patterns: 100481
Now we'll go ahead and convert our input sequences into a processed numpy array that our network can use. We'll also need to convert the numpy array values into floats so that the sigmoid activation function our network uses can interpret them and output probabilities from 0 to 1:
X = numpy.reshape(x_data, (n_patterns, seq_length, 1)) X = X/float(vocab_len)
We'll now one-hot encode our label data:
y = np_utils.to_categorical(y_data)
Since our features and labels are now ready for the network to use, let's go ahead and create our LSTM model. We specify the kind of model we want to make (a
sequential one), and then add our first layer.
We'll do dropout to prevent overfitting, followed by another layer or two. Then we'll add the final layer, a densely connected layer that will output a probability about what the next character in the sequence will be:
model = Sequential() model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2]), return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(256, return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(128)) model.add(Dropout(0.2)) model.add(Dense(y.shape[1], activation='softmax'))
We compile the model now, and it is ready for training:
model.compile(loss='categorical_crossentropy', optimizer='adam')
It takes the model quite a while to train, and for this reason we'll save the weights and reload them when the training is finished. We'll set a
checkpoint to save the weights to, and then make them the callbacks for our future model.
filepath = "model_weights_saved.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min') desired_callbacks = [checkpoint]
Now we'll fit the model and let it train.
model.fit(X, y, epochs=4, batch_size=256, callbacks=desired_callbacks)
After it has finished training, we'll specify the file name and load in the weights. Then recompile our model with the saved weights:
filename = "model_weights_saved.hdf5" model.load_weights(filename) model.compile(loss='categorical_crossentropy', optimizer='adam')
Since we converted the characters to numbers earlier, we need to define a dictionary variable that will convert the output of the model back into numbers:
num_to_char = dict((i, c) for i, c in enumerate(chars))
To generate characters, we need to provide our trained model with a random seed character that it can generate a sequence of characters from:
start = numpy.random.randint(0, len(x_data) - 1) pattern = x_data[start] print("Random Seed:") print("\"", ''.join([num_to_char[value] for value in pattern]), "\"")
Here's an example of a random seed:
" ed destruction pause peace grave succeeded sad torments thus spoke prophetic soul torn remorse horro "
Now to finally generate text, we're going to iterate through our chosen number of characters and convert our input (the random seed) into
float values.
We'll ask the model to predict what comes next based off of the random seed, convert the output numbers to characters and then append it to the pattern, which is our list of generated characters plus the initial seed:
for i in range(1000): x = numpy.reshape(pattern, (1, len(pattern), 1)) x = x / float(vocab_len) prediction = model.predict(x, verbose=0) index = numpy.argmax(prediction) result = num_to_char[index] seq_in = [num_to_char[value] for value in pattern] sys.stdout.write(result) pattern.append(index) pattern = pattern[1:len(pattern)]
Let's see what it generated.
"er ed thu so sa fare ver ser ser er serer serer serer serer serer serer serer serer serer serer serer serer serer serer serer serer serer serer...."
Does this seem somewhat disappointing? Yes, the text that was generated doesn't make any sense, and it seems to start simply repeating patterns after a little bit. However, the longer you train the network the better the text that is generated will be.
For instance, when the number of training epochs was increased to 20, the output looked more like this:
"ligther my paling the same been the this manner to the forter the shempented and the had an ardand the verasion the the dears conterration of the astore"
The model is now generating actual words, even if most of it still doesn't make sense. Still, for only around 100 lines of code, it isn't bad.
Now you can play around with the model yourself and try adjusting the parameters to get better results.
Conclusion
You'll want to increase the number of training epochs to improve the network's performance. However, you may also want to use either a deeper neural network (add more layers to the network) or a wider network (increase the number of neurons/memory units) in the layers.
You could also try adjusting the batch size, one hot-encoding the inputs, padding the input sequences, or combining any number of these ideas.
If you want to learn more about how LSTMs work, you can read up on the subject here. Learning how the parameters of the model influence the model's performance will help you choose which parameters or hyperparameters to adjust. You may also want to read up on text processing techniques and tools like those provided by NLTK.
If you'd like to read more about Natural Language Processing in Python, we've got a 12-part series that goes in-depth: Python for NLP.
You can also look at other implementations of LSTM text generation for ideas, such as Andrej Karpathy's blog post, which is one of the most famous uses of an LSTM to generate text. | https://stackabuse.com/text-generation-with-python-and-tensorflow-keras/ | CC-MAIN-2020-05 | en | refinedweb |
Kate
#include <kateregexpsearch.h>
Detailed Description
Object to help to search for regexp.
This should be NO QObject, it is created to often! I measured that, if you create it 20k times to replace for example " " in a document, that takes seconds on a modern machine!
Definition at line 40 of file kateregexpsearch.h.
Constructor & Destructor Documentation
Definition at line 168 of file kateregexpsearch.cpp.
Definition at line 177 of file kateregexpsearch.cpp.
Member Function Documentation
Returns a modified version of text where.
- escape sequences are resolved, e.g. "\\n" to "\n",
- references are resolved, e.g. "\\1" to 1st entry in capturedTexts, and
- counter sequences are resolved, e.g. "\\#...#" to replacementCounter.
- Parameters
-
- Returns
- resolved text
Definition at line 537 of file kateregexpsearch.cpp.
Returns a modified version of text where escape sequences are resolved, e.g.
"\\n" to "\n".
- Parameters
-
- Returns
- text with resolved escape sequences
Definition at line 531 of file kateregexpsearch.cpp.
regexp inside the range
inputRange.
If
backwards is true, the search direction will be reversed.
- Parameters
-
- Returns
- Vector of ranges, one for each capture. The first range (index zero) spans the full match. If the pattern does not match the vector has length 1 and holds the invalid range (see Range::isValid()).
Definition at line 201 of file kateregexpsearch.cpp.
The documentation for this class was generated from the following files:
Documentation copyright © 1996-2020 The KDE developers.
Generated on Fri Jan 17 2020 03:21:04 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006
KDE's Doxygen guidelines are available online. | https://api.kde.org/4.14-api/applications-apidocs/kate/part/html/classKateRegExpSearch.html | CC-MAIN-2020-05 | en | refinedweb |
Note Amplify iOS is in preview mode and not intended for production usage at this time. We welcome feedback to improve your experience in using Amplify iOS. CocoaPods
The fastest way to get started is adding the
amplify-tools dependency to your
Podfile:
platform :ios, '13.0' use_frameworks! target 'DataStoreApp' do pod 'amplify-tools' pod 'AmplifyPlugins/AWSDataStorePlugin' end
Then run
pod install and open the
.xcworkspace file to build your app.
Once this completes open the GraphQL schema in the
amplify/backend/api/amplifyDatasource/schema.graphql. You can use the sample or the one below that will be used in this documentation:
type Post @model { id: ID! title: String! rating: Int! status: String! }
After saving the file build your project.
You do not need an AWS account to run this and use DataStore locally, however if you wish to sync with the cloud it is recommended you Install and configure the Amplify CLI
Manual Model Generation
If you do not wish to use the above Xcode build
Open your AppDelegate and put in the following code:
import Amplify import AmplifyPlugins class AppDelegate: UIResponder, UIApplicationDelegate { //...other code do { try Amplify.add(plugin: AWSDataStorePlugin(modelRegistration: AmplifyModels())) // add after all other plugins try Amplify.configure() } catch { print("An error occurred setting up Amplify: \(error)") }.
Amplify.DataStore.save( Post(title: "My First Post", rating: 10, status: "active") ){ switch $0 { case .success: print("Added post") case .failure(let err): print("Error adding post - \(err.localizedDescription)") } }.self){ switch $0 { case .success(let result): print("Posts: \(result)") //result will be of type [Post] case .failure(let err): print("Error listing posts - \(err.localizedDescription)") } }
Query
This is done via
Amplify.DataStore.query(<Model>, where:{}). The
where statement is a closure which accepts predicates compatible with the operators listed above. For example if you wanted all of the Posts with rating greater than 4:
let p = Post.keys Amplify.DataStore.query(Post.self, where: { p.rating > 4 }){ switch $0 { case .success(let result): print("Posts: \(result)") case .failure(let err): print("Error listing posts - \(err.localizedDescription)") } }
You can build upon this with more complex
where statements using Swift operators such as
||,
&&, etc:
let p = Post.keys Amplify.DataStore.query(Post.self, where: { p.rating > 4 || p.status == "active" }){ switch $0 { case .success(let result): print("Posts: \(result)") case .failure(let err): print("Error listing posts - \(err.localizedDescription)") } }
You can also write this in a compositional function manner by replacing the operators with their equivalent predicate statements such as
.gt,
.or, etc:
let p = Post.keys Amplify.DataStore.query(Post.self, where: { p.rating.gt(4).or(p.status.eq("active")) }){ //...more code }
Update Data
Models in DataStore are immutable. To update a record you must query it to get a reference to the instance before updating it with
DataStore.save():
Amplify.DataStore.query(Post.self, byId: "123") { switch $0 { case .success(let post): print("Updating the post \(String(describing: post))") if var updatedPost = post { updatedPost.status = "inactive" Amplify.DataStore.save(updatedPost){ res in switch res { case .success: print("Post updated!") case .failure(let err): print("Failed to update post - \(err.localizedDescription)") } } } case .failure(let err): print("Post not found - \(err.localizedDescription)") } }
You can also apply conditions to update and delete operations. The condition will be applied locally and if you have enabled synchronization with the cloud it will be placed in a network mutation queue. The GraphQL mutation will then include this condition and be evaluated against the existing record in DynamoDB. If the condition holds the item in the cloud is updated and synchronized across devices. If the check fails then the item is not updated and the source of truth from the cloud will be applied to the local DataStore. For instance if you wanted to update if the
rating was greater than 3:
//TODO
Conditional updates can only be applied to single items and not lists. If you wish to update a list of items you can loop over them and apply conditions one at a time.
Delete Data
To delete an item simply pass in an instance:
Amplify.DataStore.delete(post) { switch $0 { case .success: print("Post deleted!") case .failure(let err): print("Error deleting post - \(err.localizedDescription)") } }
Or specify it by ID:
Amplify.DataStore.delete(Post.self, withId: "123") { switch $0 { case .success: print("Post deleted!") case .failure(let err): print("Error deleting post - \(err.localizedDescription)") } }
You can also pass predicate operators to delete multiple items.
// TODO
Observe Data
If you are running on iOS 13 or higher, you can subscribe to changes on your Models by using
publisher(for:) in the DataStore API. This reacts dynamically to updates of data to the underlying Storage Engine, which could be the result of GraphQL Subscriptions as well as Queries or Mutations that run against the backing AppSync API if you are synchronizing with the cloud.
The
publisher(for:) API returns an AnyPublisher, only available in iOS 13.0 and above.
let postSubscription = Amplify .DataStore .publisher(for: Post.self) .sink(receiveCompletion: { completion in if case .failure(let err) = completion { print("Subscription received error - \(err.localizedDescription)") } }) { print("Subscription received mutation: \($0)") } // When finished observing postSubscription.cancel(), either by building your project with the
amplify-tools Xcode plugin or with
amplify codegen models using the Amplify CLI.
For more information on this workflow please see the Multiple Frontends documentation.
Use Xcode
Open the
amplifyxc.config in your project and set
push to
true. Then build your app with Product > Build (CMD+B), and a push will take place.
If you do not already have a local AWS profile with credentials (automatically setup with the Amplify CLI) you will be prompted to do this on the first push.
Use Amplify CLI
amplify push
Connect your app
Once the push finishes an
amplifyconfiguration.json file will be created in your project which will be used to configure the DataStore with the cloud. Restart your app and it will connect with your backend using GraphQL queries, mutations, and subscriptions.:
type Post @model { id: ID! title: String! comments: [Comment] @connection(name: "PostComments") rating: Int! status: String! } type Comment @model { id: ID! content: String post: Post @connection(name: "PostComments") }
Saving relations
In order to save connected models you will create an instance of the model you wish to connect and pass it to
DataStore.save with the parent as an argument (
post in the below example):
let postWithComments = Post(title: "My post with comments", rating: 5, status: "active") let comment = Comment(content: "Loving Amplify DataStore", post: postWithComments) Amplify.DataStore.save(postWithComments) { switch $0 { case .failure(let err): print("Error adding post - \(err.localizedDescription)") case .success(let post): Amplify.DataStore.save(comment) { switch $0 { case .success: print("Comment saved!") case .failure(let err): print("Error adding comment - \(err.localizedDescription)") } } } }
The above example shows how to use a one-to-many schema and save connected models. For many-to-many relations, such as the one shows in the GraphQL Transformer examples you would do something like the following:
Amplify.DataStore.save(postWithEditors) { switch $0 { case .failure(let err): print("Error adding post - \(err.localizedDescription)") case .success: Amplify.DataStore.save(nadia) { switch $0 { case .failure(let err): print("Error adding user - \(err.localizedDescription)") case .success: Amplify.DataStore.save(postEditor) { switch $0 { case .failure(let err): print("Error saving postEditor - \(err.localizedDescription)") case .success: print("Saved user, post and postEditor!") } } } } } }
Models with one-to-many connections are lazy-loaded when accessing the property, so accessing a relation is as simple as:
if let comments = postWithComments.comments { for comment in comments { print(comment.content) } }
Connections are a type of Swift
Collection, which means that you can filter, map, etc:
let excitedComments = postWithComments .comments? .compactMap { $0.content } .filter { $0.contains("Wow!") }
Observing relations
let commentsSubscription = Amplify .DataStore .publisher(for: Comment.self) .tryMap { try $0.decodeModel() as? Comment } .compactMap { $0 } .sink(receiveCompletion: { completion in if case .failure(let err) = completion { print("Subscription received error - \(err.localizedDescription)") } }) { comment in print(comment.content) } // When finished observing commentsSubscription.cancel()
Deleting relations
When you delete a parent object in a one to many relationship, the children will also be removed from the DataStore and mutations for this deletion will be sent over the network. For example the following operation would remove the Post with id
123 as well as any related comments:
Amplify.DataStore.delete(postWithComments) { switch $0 { case .success: print("Post and comments deleted!") case .failure(let err): print("Error deleting post and comments - \(err.localizedDescription)") } }
However, in a many to many relationship the children are not removed and you must explicitly delete them.
Conflict Resolution
When syncing with AWS AppSync, DataStore updates from multiple clients will converge by tracking object versions and adhering | https://aws-amplify.github.io/docs/ios/datastore | CC-MAIN-2020-05 | en | refinedweb |
Import API¶
You can import local or remote datasets into CARTO via the Import API like this:
from carto.datasets import DatasetManager # write here the path to a local file or remote URL LOCAL_FILE_OR_URL = "" dataset_manager = DatasetManager(auth_client) dataset = dataset_manager.create(LOCAL_FILE_OR_URL)
The Import API is asynchronous, but the DatasetManager waits a maximum of 150 seconds for the dataset to be uploaded, so once it finishes the dataset has been created in CARTO.
Import a sync dataset¶
You can do it in the same way as a regular dataset, just include a sync_time parameter with a value >= 900 seconds
from carto.datasets import DatasetManager # how often to sync the dataset (in seconds) SYNC_TIME = 900 # write here the URL for the dataset to sync URL_TO_DATASET = "" dataset_manager = DatasetManager(auth_client) dataset = dataset_manager.create(URL_TO_DATASET, SYNC_TIME)
Alternatively, if you need to do further work with the sync dataset, you can use the SyncTableJobManager
from carto.sync_tables import SyncTableJobManager import time # how often to sync the dataset (in seconds) SYNC_TIME = 900 # write here the URL for the dataset to sync URL_TO_DATASET = "" syncTableManager = SyncTableJobManager(auth_client) syncTable = syncTableManager.create(URL_TO_DATASET, SYNC_TIME) # return the id of the sync sync_id = syncTable.get_id() while(syncTable.state != 'success'): time.sleep(5) syncTable.refresh() if (syncTable.state == 'failure'): print('The error code is: ' + str(syncTable.error_code)) print('The error message is: ' + str(syncTable.error_message)) break # force sync syncTable.refresh() syncTable.force_sync()
Get a list of all the current import jobs¶
from carto.file_import import FileImportJobManager file_import_manager = FileImportJobManager(auth_client) file_imports = file_import_manager.all()
Get all the datasets¶
from carto.datasets import DatasetManager dataset_manager = DatasetManager(auth_client) datasets = dataset_manager.all()
Get a specific dataset¶
from carto.datasets import DatasetManager # write here the ID of the dataset to retrieve DATASET_ID = "" dataset_manager = DatasetManager(auth_client) dataset = dataset_manager.get(DATASET_ID)
Delete a dataset¶
from carto.datasets import DatasetManager # write here the ID of the dataset to retrieve DATASET_ID = "" dataset_manager = DatasetManager(auth_client) dataset = dataset_manager.get(DATASET_ID) dataset.delete()
Please refer to the carto package API documentation and the examples folder to find out about the rest of the parameters accepted by constructors and methods.
External database connectors¶
The CARTO Python client implements the database connectors feature of the Import API
The database connectors allow importing data from an external database into a CARTO table by using the connector parameter.
There are several types of database connectors that you can connect to your CARTO account.
Please refer to the database connectors documentation for supported external databases.
As an example, this code snippets imports data from a Hive table into CARTO:
from carto.datasets import DatasetManager dataset_manager = DatasetManager(auth_client) connection = { "connector": { "provider": "hive", "connection": { "server": "YOUR_SERVER_IP", "database": "default", "username": "YOUR_USER_NAME", "password": "YOUR_PASSWORD" }, "schema": "default", "table": "YOUR_HIVE_TABLE" } } table = dataset_manager.create(None, None, connection=connection)
You still can configure a sync external database connector, by providing the interval parameter:
table = dataset_manager.create(None, 900, connection=connection)
DatasetManager vs FileImportJobManager and SyncTableJobManager¶
The DatasetManager is conceptually different from both FileImportJobManager and SyncTableJobManager. These later ones are JobManagers, that means that they create and return a job using the CARTO Import API. It’s responsibility of the developer to check the state of the job to know whether the dataset import job is completed, or has failed, errored, etc.
As an example, this code snippet uses the FileImportJobManager to create an import job:
# write here the URL for the dataset or the path to a local file (local to the server...) LOCAL_FILE_OR_URL = "" file_import_manager = FileImportJobManager(auth_client) file_import = file_import_manager.create(LOCAL_FILE_OR_URL) # return the id of the import file_id = file_import.get_id() file_import.run() while(file_import.state != "complete" and file_import.state != "created" and file_import.state != "success"): time.sleep(5) file_import.refresh() if (file_import.state == 'failure'): print('The error code is: ' + str(file_import)) break
Note that with the FileImportJobManager we are creating an import job and we check the state of the job.
On the other hand the DatasetManager is an utility class that works at the level of Dataset. It creates and returns a Dataset instance. Internally, it uses a FileImportJobManager or a SyncTableJobManager depending on the parameters received and is able to automatically check the state of the job it creates to properly return a Dataset instance once the job finishes successfully or a CartoException in any other case.
As an example, this code snippet uses the DatasetManager to create a dataset:
# write here the path to a local file (local to the server...) or remote URL LOCAL_FILE_OR_URL = "" # to use the DatasetManager you need an enterprise account auth_client = APIKeyAuthClient(BASE_URL, API_KEY) dataset_manager = DatasetManager(auth_client) dataset = dataset_manager.create(LOCAL_FILE_OR_URL) # the create method will wait up to 10 minutes until the dataset is uploaded.
In this case, you don’t have to check the state of the import job, since it’s done automatically by the DatasetManager. On the other hand, you get a Dataset instance as a result, instead of a FileImportJob instance. | https://carto-python.readthedocs.io/en/1.3.0/import_api.html | CC-MAIN-2020-05 | en | refinedweb |
draw each segment in a glyph?
I've been trying to figure out how to animate the drawing of each segment in a glyph (from DrawBot plugin in RF). For example this zigzag path, before it got outlined:
I've tried writing something like:
glyph = CurrentGlyph() newGlyph = RGlyph() for contour in glyph: newContour = RContour() newGlyph.appendContour(newContour) for segment in contour: newGlyph.appendSegment(segment) drawGlyph(newGlyph)
so far I've found that appendSegment doesn't work as I would expect it to (or at all?). And I'm thinking there's a better way to do this using pens, but haven't been able to figure out how to step through each segment using a pen and draw them one by one.
Eventually I'd like to draw only every nth frame so the animation goes faster.
If anyone has suggestions for how to do this, please let me know. Thanks so much!
- justvanrossum last edited by justvanrossum
@cj Apart from writing your own "filter pen", one could do something like this:
from fontTools.pens.recordingPen import RecordingPen g = CurrentGlyph() p = RecordingPen() g.draw(p) for op, args in p.value: print(op, args) #getattr(otherPen, op)(*args) # forward pen calls to another pen
This way you get to see exactly which calls to the pen object
glyph.draw(pen)causes.
To use the pen protocol on a glyph, do something like:
g = RGlyph() p = g.getPen() p.moveTo((100, 200)) p.lineTo((100, 300)) p.curveTo(p1, p2, p3) p.closePath()
@justvanrossum thanks so much!
For anyone else trying this, for some reason I was getting an error when I had
from fontTools.pens.recordingPen import RecordingPen
error was
ImportError: No module named recordingPen
Perhaps because recordingPen.py isn't in the version of fontTools packaged with RoboFont?
Anyway, I just copy/pasted the whole RecordingPen code from fontTools into my script:
from fontTools.pens.basePen import AbstractPen class RecordingPen(AbstractPen): """Pen recording operations that can be accessed or replayed. The recording can be accessed as pen.value; or replayed using pen.replay(otherPen). Usage example: ============== from fontTools.ttLib import TTFont from fontTools.pens.recordingPen import RecordingPen glyph_name = 'dollar' font_path = 'MyFont.otf' font = TTFont(font_path) glyphset = font.getGlyphSet() glyph = glyphset[glyph_name] pen = RecordingPen() glyph.draw(pen) print(pen.value) """ def __init__(self): self.value = [] def moveTo(self, p0): self.value.append(('moveTo', (p0,))) def lineTo(self, p1): self.value.append(('lineTo', (p1,))) def qCurveTo(self, *points): self.value.append(('qCurveTo', points)) def curveTo(self, *points): self.value.append(('curveTo', points)) def closePath(self): self.value.append(('closePath', ())) def endPath(self): self.value.append(('endPath', ())) def addComponent(self, glyphName, transformation): self.value.append(('addComponent', (glyphName, transformation))) def replay(self, pen): replayRecording(self.value, pen)
and now I can run the script that Just wrote above. Thanks again! | https://forum.drawbot.com/topic/27/draw-each-segment-in-a-glyph | CC-MAIN-2020-05 | en | refinedweb |
Thread
2004.10.01 13:21 "Re: [Tiff] BigTIFF & PDF & tifftools", by Frank Warmerdam
>Rob wrote:
Discussion was about tifftools, and if/when they would grow 'big' too.
Would these tools become bigtiff specific or would they handle bigtiff and classic tiff transparantly?
Linking them with both lib's could introduce namespace conflicts I guess.
Having separate tools for classic and big would give double code bases for every tool implying a serious synchronisation effort.
Joris wrote:
As far as I know, having LibTiff handle the classic/big issue transparently, is not just possible, but is also the way Frank intends to enhance LibTiff. It will enable to stick with a single copy of the tools and tools code. Tools will not need to grow big, neither will apps, they'll support BigTIFF by default simply by using the newer LibTiff.
Folks,
First, it will be Andrey who does the BigTIFF upgrade. While I am very keen on it, I am not really prepared to put in the time to ensure it is done right.
And yes, our intent is that we would have a single library that supports both. There will certainly be some ABI changes to libtiff with the upgrade to BigTIFF support, and there will presumably be some extra options available to control whether BigTIFF or classic TIFF should be generated. So I don't think it will be completely a transparent upgrade for write purposes if you want to be able to produce BigTIFF.
But reading BigTIFF or classic TIFF files should be transparent to the application at the source level. And I hopefully TIFF reading applications that don't dig in too deep should not require any source changes either.
The ABI changes are likely to include stuff like toff_t and tsize_t becoming 64 bit types on platforms which support them.
As for Robs first question, I have no idea if PDF supports file sizes larger than 4GB or if that would be supported by tiff2pdf. I can't honestly imagine wanting to produce such a large PDF file for some years to come.
Best regards,
--
---------------------------------------+--------------------------------------
I set the clouds in motion - turn up | Frank Warmerdam, warmerdam@pobox.com
light and sound - activate the windows |
and watch the world go round - Rush | Geospatial Programmer for Rent | https://www.asmail.be/msg0055490954.html | CC-MAIN-2020-05 | en | refinedweb |
(This feature was released in v1.1.0)
JSON Schema is a draft standard for describing the format of JSON data. The schema itself is also JSON data. By validating a JSON structure with JSON Schema, your code can safely access the DOM without manually checking types, or whether a key exists, etc. It can also ensure that the serialized JSON conform to a specified schema.
RapidJSON implemented a JSON Schema validator for JSON Schema Draft v4. If you are not familiar with JSON Schema, you may refer to Understanding JSON Schema.
First of all, you need to parse a JSON Schema into
Document, and then compile the
Document into a
SchemaDocument.
Secondly, construct a
SchemaValidator with the
SchemaDocument. It is similar to a
Writer in the sense of handling SAX events. So, you can use
document.Accept(validator) to validate a document, and then check the validity.
#include "rapidjson/schema.h" // ... Document sd; if (sd.Parse(schemaJson).HasParseError()) { // the schema is not a valid JSON. // ... } SchemaDocument schema(sd); // Compile a Document to SchemaDocument // sd is no longer needed here. Document d; if (d.Parse(inputJson).HasParseError()) { // the input is not a valid JSON. // ... } SchemaValidator validator(schema); if (!d.Accept(validator)) { // Input JSON is invalid according to the schema // Output diagnostic information StringBuffer sb; validator.GetInvalidSchemaPointer().StringifyUriFragment(sb); printf("Invalid schema: %s\n", sb.GetString()); printf("Invalid keyword: %s\n", validator.GetInvalidSchemaKeyword()); sb.Clear(); validator.GetInvalidDocumentPointer().StringifyUriFragment(sb); printf("Invalid document: %s\n", sb.GetString()); }
Some notes:
SchemaDocumentcan be referenced by multiple
SchemaValidators. It will not be modified by
SchemaValidators.
SchemaValidatormay be reused to validate multiple documents. To run it for other documents, call
validator.Reset()first.
Unlike most JSON Schema validator implementations, RapidJSON provides a SAX-based schema validator. Therefore, you can parse a JSON from a stream while validating it on the fly. If the validator encounters a JSON value that invalidates the supplied schema, the parsing will be terminated immediately. This design is especially useful for parsing large JSON files.
For using DOM in parsing,
Document needs some preparation and finalizing tasks, in addition to receiving SAX events, thus it needs some work to route the reader, validator and the document.
SchemaValidatingReader is a helper class that doing such work.
#include "rapidjson/filereadstream.h" // ... SchemaDocument schema(sd); // Compile a Document to SchemaDocument // Use reader to parse the JSON FILE* fp = fopen("big.json", "r"); FileReadStream is(fp, buffer, sizeof(buffer)); // Parse JSON from reader, validate the SAX events, and store in d. Document d; SchemaValidatingReader<kParseDefaultFlags, FileReadStream, UTF8<> > reader(is, schema); d.Populate(reader); if (!reader.GetParseResult()) { // Not a valid JSON // When reader.GetParseResult().Code() == kParseErrorTermination, // it may be terminated by: // (1) the validator found that the JSON is invalid according to schema; or // (2) the input stream has I/O error. // Check the validation result if (!reader.IsValid()) { // Input JSON is invalid according to the schema // Output diagnostic information StringBuffer sb; reader.GetInvalidSchemaPointer().StringifyUriFragment(sb); printf("Invalid schema: %s\n", sb.GetString()); printf("Invalid keyword: %s\n", reader.GetInvalidSchemaKeyword()); sb.Clear(); reader.GetInvalidDocumentPointer().StringifyUriFragment(sb); printf("Invalid document: %s\n", sb.GetString()); } }
For using SAX in parsing, it is much simpler. If it only need to validate the JSON without further processing, it is simply:
SchemaValidator validator(schema); Reader reader; if (!reader.Parse(stream, validator)) { if (!validator.IsValid()) { // ... } }
This is exactly the method used in the schemavalidator example. The distinct advantage is low memory usage, no matter how big the JSON was (the memory usage depends on the complexity of the schema).
If you need to handle the SAX events further, then you need to use the template class
GenericSchemaValidator to set the output handler of the validator:
MyHandler handler; GenericSchemaValidator<SchemaDocument, MyHandler> validator(schema, handler); Reader reader; if (!reader.Parse(ss, validator)) { if (!validator.IsValid()) { // ... } }
It is also possible to do validation during serializing. This can ensure the result JSON is valid according to the JSON schema.
StringBuffer sb; Writer<StringBuffer> writer(sb); GenericSchemaValidator<SchemaDocument, Writer<StringBuffer> > validator(s, writer); if (!d.Accept(validator)) { // Some problem during Accept(), it may be validation or encoding issues. if (!validator.IsValid()) { // ... } }
Of course, if your application only needs SAX-style serialization, it can simply send SAX events to
SchemaValidator instead of
Writer.
JSON Schema supports
$ref keyword, which is a JSON pointer referencing to a local or remote schema. Local pointer is prefixed with
#, while remote pointer is an relative or absolute URI. For example:
{ "$ref": "definitions.json#/address" }
As
SchemaDocument does not know how to resolve such URI, it needs a user-provided
IRemoteSchemaDocumentProvider instance to do so.
class MyRemoteSchemaDocumentProvider : public IRemoteSchemaDocumentProvider { public: virtual const SchemaDocument* GetRemoteDocument(const char* uri, SizeType length) { // Resolve the uri and returns a pointer to that schema. } }; // ... MyRemoteSchemaDocumentProvider provider; SchemaDocument schema(sd, &provider);
RapidJSON passed 262 out of 263 tests in JSON Schema Test Suite (Json Schema draft 4).
The failed test is “changed scope ref invalid” of “change resolution scope” in
refRemote.json. It is due to that
id schema keyword and URI combining function are not implemented.
Besides, the
format schema keyword for string values is ignored, since it is not required by the specification.
The schema keyword
pattern and
patternProperties uses regular expression to match the required pattern.
RapidJSON implemented a simple NFA regular expression engine, which is used by default. It supports the following syntax.
For C++11 compiler, it is also possible to use the
std::regex by defining
RAPIDJSON_SCHEMA_USE_INTERNALREGEX=0 and
RAPIDJSON_SCHEMA_USE_STDREGEX=1. If your schemas do not need
pattern and
patternProperties, you can set both macros to zero to disable this feature, which will reduce some code size.
Most C++ JSON libraries do not yet support JSON Schema. So we tried to evaluate the performance of RapidJSON's JSON Schema validator according to json-schema-benchmark, which tests 11 JavaScript libraries running on Node.js.
That benchmark runs validations on JSON Schema Test Suite, in which some test suites and tests are excluded. We made the same benchmarking procedure in
schematest.cpp.
On a Mac Book Pro (2.8 GHz Intel Core i7), the following results are collected.
That is, RapidJSON is about 1.5x faster than the fastest JavaScript library (ajv). And 1400x faster than the slowest one.
(Unreleased as of 2017-09-20)
When validating an instance against a JSON Schema, it is often desirable to report not only whether the instance is valid, but also the ways in which it violates the schema.
The
SchemaValidator class collects errors encountered during validation into a JSON
Value. This error object can then be accessed as
validator.GetError().
The structure of the error object is subject to change in future versions of RapidJSON, as there is no standard schema for violations. The details below this point are provisional only.
Validation of an instance value against a schema produces an error value. The error value is always an object. An empty object
{} indicates the instance is valid.
Each violation object contains two string-valued members named
instanceRef and
schemaRef.
instanceRef contains the URI fragment serialization of a JSON Pointer to the instance subobject in which the violation was detected.
schemaRef contains the URI of the schema and the fragment serialization of a JSON Pointer to the subschema that was violated.
Individual violation objects can contain other keyword-specific members. These are detailed further.
For example, validating this instance:
{"numbers": [1, 2, "3", 4, 5]}
against this schema:
{ "type": "object", "properties": { "numbers": {"$ref": "numbers.schema.json"} } }
where
numbers.schema.json refers (via a suitable
IRemoteSchemaDocumentProvider) to this schema:
{ "type": "array", "items": {"type": "number"} }
produces the following error object:
{ "type": { "instanceRef": "#/numbers/2", "schemaRef": "numbers.schema.json#/items", "expected": ["number"], "actual": "string" } }
expected: required number strictly greater than 0. The value of the
multipleOfkeyword specified in the schema.
actual: required number. The instance value.
expected: required number. The value of the
maximumkeyword specified in the schema.
exclusiveMaximum: optional boolean. This will be true if the schema specified
"exclusiveMaximum": true, and will be omitted otherwise.
actual: required number. The instance value.
expected: required number. The value of the
minimumkeyword specified in the schema.
exclusiveMinimum: optional boolean. This will be true if the schema specified
"exclusiveMinimum": true, and will be omitted otherwise.
actual: required number. The instance value.
expected: required number greater than or equal to 0. The value of the
maxLengthkeyword specified in the schema.
actual: required string. The instance value.
expected: required number greater than or equal to 0. The value of the
minLengthkeyword specified in the schema.
actual: required string. The instance value.
actual: required string. The instance value.
(The expected pattern is not reported because the internal representation in
SchemaDocument does not store the pattern in original string form.)
This keyword is reported when the value of
items schema keyword is an array, the value of
additionalItems is
false, and the instance is an array with more items than specified in the
items array.
disallowed: required integer greater than or equal to 0. The index of the first item that has no corresponding schema.
expected: required integer greater than or equal to 0. The value of
maxItems(respectively,
minItems) specified in the schema.
actual: required integer greater than or equal to 0. Number of items in the instance array.
duplicates: required array whose items are integers greater than or equal to 0. Indices of items of the instance that are equal.
(RapidJSON only reports the first two equal items, for performance reasons.)
expected: required integer greater than or equal to 0. The value of
maxProperties(respectively,
minProperties) specified in the schema.
actual: required integer greater than or equal to 0. Number of properties in the instance object.
missing: required array of one or more unique strings. The names of properties that are listed in the value of the
requiredschema keyword but not present in the instance object.
This keyword is reported when the schema specifies
additionalProperties: false and the name of a property of the instance is neither listed in the
properties keyword nor matches any regular expression in the
patternProperties keyword.
disallowed: required string. Name of the offending property of the instance.
(For performance reasons, RapidJSON only reports the first such property encountered.)
errors: required object with one or more properties. Names and values of its properties are described below.
Recall that JSON Schema Draft 04 supports schema dependencies, where presence of a named controlling property requires the instance object to be valid against a subschema, and property dependencies, where presence of a controlling property requires other dependent properties to be also present.
For a violated schema dependency,
errors will contain a property with the name of the controlling property and its value will be the error object produced by validating the instance object against the dependent schema.
For a violated property dependency,
errors will contain a property with the name of the controlling property and its value will be an array of one or more unique strings listing the missing dependent properties.
This keyword has no additional properties beyond
instanceRef and
schemaRef.
SchemaDocumentdoes not store them in original form.
If you need to report these details to your users, you can access the necessary information by following
instanceRef and
schemaRef.
expected: required array of one or more unique strings, each of which is one of the seven primitive types defined by the JSON Schema Draft 04 Core specification. Lists the types allowed by the
typeschema keyword.
actual: required string, also one of seven primitive types. The primitive type of the instance.
errors: required array of at least one object. There will be as many items as there are subschemas in the
allOf,
anyOfor
oneOfschema keyword, respectively. Each item will be the error value produced by validating the instance against the corresponding subschema.
For
allOf, at least one error value will be non-empty. For
anyOf, all error values will be non-empty. For
oneOf, either all error values will be non-empty, or more than one will be empty.
This keyword has no additional properties apart from
instanceRef and
schemaRef. | https://android.googlesource.com/platform/external/rapidjson/+/HEAD/doc/schema.md | CC-MAIN-2021-10 | en | refinedweb |
Subject: Re: [boost] [filesystem] Version 3 of Boost.Filesystem added to trunk
From: Andrey Semashev (andrey.semashev_at_[hidden])
Date: 2010-06-05 04:31:31
On 06/04/2010 08:55 PM, Steven Watanabe wrote:
>
> Is this thread-safe?
It seems not. It uses path_locale function that has an unprotected
function-local static. I can also see a few namespace-scope non-POD
variables in *.cpp.
Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk | https://lists.boost.org/Archives/boost/2010/06/167675.php | CC-MAIN-2021-10 | en | refinedweb |
Opened 9 years ago
Closed 9 years ago
Last modified 9 years ago
#31216 closed enhancement (fixed)
build python against libedit instead of readline
Description
GNU readline is licensed under GPL-3+, whereas libedit is BSD. Using libedit will therefore make the binary distribution situation easier. This is actually the default configuration on OS X for upstream anyway, as Apple's libreadline is a link to libedit.
Should just be a matter of patching the configure script to change -lreadline to -ledit and readline/readline.h to editline/readline.h.
Attachments (1)
Change History (10)
comment:1 Changed 9 years ago by ned-deily (Ned Deily)
comment:2 Changed 9 years ago by jmroot (Joshua Root)
Turns out the incompatibility is fixed in the version of libedit we now install, which means it actually crashes unless we revert the upstream python patch.
Also, readline is in a separate port for python24, so this is not a big deal for that version.
Changed 9 years ago by jmroot (Joshua Root)
comment:3 Changed 9 years ago by jmroot (Joshua Root)
comment:4 Changed 9 years ago by jmroot (Joshua Root)
comment:5 Changed 9 years ago by ned-deily (Ned Deily)
Note that linking with libedit instead of GNU readline introduces potential user incompatibilities. As noted in the docs for the Python readline module , the configuration file commands for libedit are different than readline. For example, if you have a PYTHONSTARTUP file set up to enable tab completion in the Python interactive interpreter, the directives have to be changed or be conditional based on which library is used or directives have to be added to .editrc (the libedit defaults file). Here's an example:
import rlcompleter if 'libedit' in readline.__doc__: readline.parse_and_bind("bind ^I rl_complete") else: # GNU readline format readline.parse_and_bind("tab: complete")
Also, py27-ipython and py32-ipython (at least) complain when running with a python linked with libedit:
/macports/Library/Frameworks/Python.framework/Versions/2.7/lib/python2)
comment:6 Changed 9 years ago by cdeil (Christoph Deil)
I have the same problem with ipython. Actually the ipython prompt is broken:
$ /opt/local/bin/ipython-2.6 /opt/local/Library/Frameworks/Python.framework/Versions/2.6/lib/python2) Python 2.6.7 (r267:88850, Nov 8 2011, 12:13:06) Type "copyright", "credits" or "license" for more information. IPython 0.11 -- An enhanced Interactive Python. ? -> Introduction and overview of IPython's features. %quickref -> Quick reference. help -> Python's own help system. object? -> Details about 'object', use 'object??' for extra details. 34In[1;3[0;34][0^D
Same warning and broken prompt whether I use ipython from MacPorts of the git master.
Any workaround / fix from this from the Macports or Ipython side? Should I file a new ticket?
comment:7 Changed 9 years ago by cdeil (Christoph Deil)
Cc Me!
comment:8 Changed 9 years ago by spork-macports@…
Cc Me!
Note that there was feature code added to Python to support using libedit instead of readline. That feature code was added to python26, python27, and python32 but not other versions; see | https://trac.macports.org/ticket/31216 | CC-MAIN-2021-10 | en | refinedweb |
How to Code Complex Applications: Core Java Technology and Architecture
11.11 Big Sale for Cloud. Get unbeatable offers with up to 90% off on cloud servers and up to $300 rebate for all products! Click here to learn more.
Everyone who follows my work knows that I have been committed to the governance of application architecture and code complexity. Recently, I have been studying the code of the Ling Shou Tong product domain. The complex business scenario of Ling Shou Tong poses a new challenge at the architecture and code levels. To address the challenge, I have conducted a carefully thought out study. On the basis of the actual business scenario, I have developed a set of methodologies on how to code complex applications, and today, I would like to share these methodologies with you.
Processing of Complex Application: Background
Let’s begin with a brief background about Ling Shou Tong. It is a B2B model for offline stores that is developed to reconstruct traditional supply chain channels through digitization for improving supply chain efficiency and boosting New Retail. In this process, Alibaba acts as the platform that provides the service functions of Bsbc.
Firstly, in the product domain, a “launch” action is performed. Once, the product is launched, it can be sold to various mom-and-pop stores through Ling Shou Tong. Launching a product is one of the key business operations in Ling Shou Tong. Therefore, it involves several verification and association operations. A simplified business process for product launching is illustrated below:
Process Decomposition
For addressing a complex business scenario, writing code by using a service method is not feasible. So, if there is no way to address it by using one class, it is recommended to use decomposition instead.
Actually, if engineers can recall the “divide and conquer” method, it is regarded as a good job. At least, it is better to have the consideration for decomposition than none. I have also encountered business scenarios of similar complexity, which are processed by using a number of methods and classes without decomposition.
However, there is a challenge with decomposition as well. Many engineers rely too much on tools or auxiliary means to implement decomposition. For example, in our product domain, we have a minimum of three similar decomposition methods, such as self-made process engines and database-based process handling.
To put it simply, all these methods are only auxiliary to the pipeline processing and do not add anything considerable. Therefore, I recommend that we follow the Keep It Simple and Stupid (KISS) approach by not using any tools with a simple pipeline mode as the suboptimal choice and methods such as process engines as the last choice. Unless your application has a strong demand for process visualization and orchestration, it is recommended not to use any tools such as process engines. This is suggested, primarily because it introduces additional complexity, especially when the process engines require persistence, and secondly, as it splits the code, which results in poor readability of the code. To be bold, it is estimated that 80% of the use of process engines is not worthwhile.
Coming back to the main topic of product launching, there are few essential questions that need to be addressed:
- Do the adopted tools form the core of the topic?
- Does the code flexibility introduced by the design mode form the core of the topic?
Apparently, answers to both these questions is a clear “no”. The core point should be how to break down the problem and abstract it. If you know the pyramid principle, you can use structured decomposition to deconstruct the problem into a hierarchical pyramid structure as shown below:
The code written as per the decomposition method is like a book with clear directories and content. Taking the example of product launching, the program entry is an OnSale command that consists of three phases.
@Command
public class OnSaleNormalItemCmdExe { @Resource
private OnSaleContextInitPhase onSaleContextInitPhase;
@Resource
private OnSaleDataCheckPhase onSaleDataCheckPhase;
@Resource
private OnSaleProcessPhase onSaleProcessPhase; @Override
public Response execute(OnSaleNormalItemCmd cmd) {
OnSaleContext onSaleContext = init(cmd);
checkData(onSaleContext); process(onSaleContext); return Response.buildSuccess();
} private OnSaleContext init(OnSaleNormalItemCmd cmd) {
return onSaleContextInitPhase.init(cmd);
} private void checkData(OnSaleContext onSaleContext) {
onSaleDataCheckPhase.check(onSaleContext);
} private void process(OnSaleContext onSaleContext) {
onSaleProcessPhase.process(onSaleContext);
}
}
Each of these phases can be split into multiple steps. Using the
OnSaleProcessPhase as an example, it contains a series of steps as mentioned below:
@Phase
public class OnSaleProcessPhase { @Resource
private PublishOfferStep publishOfferStep;
@Resource
private BackOfferBindStep backOfferBindStep;
//omit other steps public void process(OnSaleContext onSaleContext){
SupplierItem supplierItem = onSaleContext.getSupplierItem(); // generate OfferGroupNo
generateOfferGroupNo(supplierItem);
// publish offer
publishOffer(supplierItem); // bind back offer stock
bindBackOfferStock(supplierItem); // synchroize sotck
syncStockRoute(supplierItem); // set virtual product tag
setVirtualProductExtension(supplierItem); // set procteciton label
markSendProtection(supplierItem); // record Change Details
recordChangeDetail(supplierItem); // synchronize price
syncSupplyPriceToBackOffer(supplierItem); // set exteinsion info
setCombineProductExtension(supplierItem); // remove sellout tag
removeSellOutTag(offerId); // fire domian event
fireDomainEvent(supplierItem);
// close to-do issues
closeIssues(supplierItem);
}
}
In this process of complex product launching scenario, it is crucial to answer the following two questions:
- Is a process engine required?
- Is the support of a design mode required?
The answer to both the questions is “No”, and hence the simple composed method cannot be more applicable to express such a business process.
Therefore, while implementing process decomposition, it is suggested that engineers should not focus too much on tools or the flexibility brought about by design modes. Instead, we should spend more time on problem analysis, structural decomposition, and reasonable abstraction to finally obtain appropriate phases and steps.
Post Process Decomposition Challenges
The code after process decomposition is clearer and easier to maintain than before. However, it is important to note the following two problems associated with decomposition:
- Fragmented Domain Knowledge: There is no place for domain knowledge aggregation. The code for each use case is only specific to its own process, and the knowledge is not centrally accumulated. The same business logic is implemented repeatedly in multiple use cases, which leads to a severe code repetition. Though code can be reused, only one snippet can be extracted for reuse at most.
- Code Failure to Express Business Semantics: While coding for a process, it is expected to express how to obtain data, perform computation, and store the resulting data. In this case, it is hard to realize the same because models and the relationship between the models are missing. Being separated from models, business semantic expressions lose their rhythm and soul.
For example, a verification is performed to check the inventory during the product launching process. The inventory processing of combined products (CombineBackOffer) is different from that of ordinary products. The original code mentioned below:
boolean isCombineProduct = supplierItem.getSign().isCombProductQuote();// supplier.usc warehouse needn't check
if (WarehouseTypeEnum.isAliWarehouse(supplierItem.getWarehouseType())) {
// quote warehosue check
if (CollectionUtil.isEmpty(supplierItem.getWarehouseIdList()) && !isCombineProduct) {
throw ExceptionFactory.makeFault(ServiceExceptionCode.SYSTEM_ERROR, "You cant publish offer, since there is no warehouse info");
}
// inventory amount check
Long sellableAmount = 0L;
if (!isCombineProduct) {
sellableAmount = normalBiz.acquireSellableAmount(supplierItem.getBackOfferId(), supplierItem.getWarehouseIdList());
} else {
//combination product
OfferModel backOffer = backOfferQueryService.getBackOffer(supplierItem.getBackOfferId());
if (backOffer != null) {
sellableAmount = backOffer.getOffer().getTradeModel().getTradeCondition().getAmountOnSale();
}
}
if (sellableAmount < 1) {
throw ExceptionFactory.makeFault(ServiceExceptionCode.SYSTEM_ERROR, "Your stock is less than 1, please supply more items. The product id:" + supplierItem.getId() + "]");
}
}
However, if we introduce the domain model in the system, the code will be simplified as follows:
if(backOffer.isCloudWarehouse()){
return;
}if (backOffer.isNonInWarehouse()){
throw new BizException("You cant publish offer, since there is no warehouse info");
}if (backOffer.getStockAmount() < 1){
throw new BizException("Your stock is less than 1, please supply more items,The product id:" + backOffer.getSupplierItem().getCspuCode() + "]");
}
Obviously, the expression after using a model is much clearer and easier to understand. In addition, you do not need to make judgments on whether they are combined products or not. Due to a more realistic object model (CombineBackOffer inherits BackOffer) adopted in the system, we can eliminate most of the if-else statements in our code through object polymorphism.
Process Decomposition Plus Object Models
From the preceding case, we can infer that using process decomposition is better than none. Furthermore, process decomposition plus object models are better than process decomposition alone. In the case of product launching, if we adopt process decomposition plus object models, we will get the following system structure:
Methodologies Used to Code Complex Applications
In the preceding sections, we covered how to code complex applications. To be precise, it is the combination of top-down structured decomposition and bottom-up object-oriented analysis. Now, let us further abstract the preceding case to form a feasible methodology that can be used in more complex business scenarios.
Top-down and Bottom-up Combination
The top-down and bottom-up combination suggests combining top-down process decomposition and bottom-up object modeling to spirally build our application system. This is a dynamic process. The two operations can be carried out alternately or simultaneously. Moreover, they complement each other. The upper layer analysis can help us better clarify the relationship between models, while the lower layer model expression can improve our code reusability and business semantic expression capabilities.
The following figure shows the process:
This combination helps us to write clean and easy-to-maintain code for any complex business scenarios.
Capability Sink-in
While using the domain-driven design (DDD) in practice, we experience the following two phases:
- Using Only Concepts: In this phase, you may understand few concepts of DDD, and eventually use some of them including the Aggregation Root, Bonded Context, Repository concepts while coding. Further, you may also use some layered strategies. However, this has little effect on complexity governance.
- Achieving Mastery: In this phase, terms become less important. You can understand the essence of DDD, which is a method of establishing a ubiquitous language, defining boundaries, and performing object-oriented analysis.
With reference to my approach, I would define myself near the second phase due to the questions that have been perplexing me: What capabilities should be placed on the Domain layer, and is it reasonable to follow the tradition to collect all services to the Domain layer? To be honest, I have never found answers to these questions.
In real business scenarios, many capabilities are specific to use cases. If you use the Domain layer to collect services blindly, it is likely that little benefit is obtained. On the contrary, the collection will lead to the expansion of the Domain layer, which will affect reusability and expression capability.
In this view, I think that we should adopt the strategy of capability sink-in. It implies that we do not force ourselves to design all capabilities of the Domain layer at one time, and we do not have to place all business capabilities on the Domain layer. Instead, we must adopt a pragmatic attitude, for abstracting and extracting only the capabilities that need to be reused in multiple scenarios and temporarily put the capabilities that are not reused in the use cases at the App layer.
Note: Use case is a term used in the book Clean Architecture. To express this term in a simple manner, it is the process of responding to a request.
Through practice, I have found that this step-by-step capability sink-in strategy is a more practical and agile method, as we agree that the model is not designed at one time, and is a result of iterations.
The sink-in process is shown in the following figure. If we find that step 3 of use case 1 and step 1 of use case 2 have similar capabilities, we can consider extracting and migrating the capabilities to the Domain layer. In this way, code reusability is improved.
Code Reusability and Cohesion: Two Key criteria in the Sink-in
Reusability is about determining when the sink-in should be performed or to put it simply, when the code is repeated. Cohesion is about ascertaining how the sink-in should be performed, in other words, whether a capability is cohesive to an appropriate entity, and whether it is placed on the appropriate layer.
The Domain layer has two levels of capabilities: One is domain service, which is relatively coarse-grained, and the other is the domain model, which is the most fine-grained reuse. For example, in our product domain, a capability is often required to determine whether a product is the smallest unit or a middle package. It is necessary that such a capability should be directly cohesive to a domain model.
public class CSPU {
private String code;
private String baseCode;
//omit other attributes /**
* check if it is minimumu unit
*
*/
public boolean isMinimumUnit(){
return StringUtils.equals(code, baseCode);
} /**
* check if it is middle package
*
*/
public boolean isMidPackage(){
return StringUtils.equals(code, midPackageCode);
}
}
Traditional models didn’t have any domain model or CSPU entity. As a result, you can find that the logic for determining whether a single product is the smallest unit is scattered in the code in the form of
StringUtils.equals (code, baseCode). Such code always has poor intelligibility and it is difficult to infer what it means at first sight.
How Should We Practice Application Development
Here, I would like to answer the questions that have confused many peers who are engaged in application development.
- Should application development focus on business implementation or technology?
- What is the technical significance of application development?
From the preceding case, we can comprehend that the complexity of application development is no less than framework development. It is not easy to code applications. The only difference between application and framework development personnel is that they are dealing with different problem domains.
While application development involves more domain changes and more people, framework development involves more stable problem domains but more sophisticated technologies. For example, if you want to develop Pandora, you must have a deep understanding of the Classloader.
However, all the application and framework development personnel share certain thinking patterns and abilities. For example, the ability to break down problems, abstract thinking, and structured thinking.
In my opinion, if a developer cannot do well in application development, he or she cannot do well in framework development either, and vice versa. Application development is not simple at all. However, many of us have treated it in a simple manner.
In addition, from the perspective of changes, the difficulty of application development is not inferior to that of framework development, and application development faces even greater challenges. Therefore, as closing thoughts, I would like to suggest to all peers engaged in application development, to:
- Consolidate their capabilities, including basic technical capabilities, object-orientation (OO) capabilities, and modeling capabilities.
- Constantly improve abstract, structured, and critical thinking.
- Continue to learn and improve code quality. We can do a lot of technical work as an application developer.
Postscript
This article is a summary of my recent thoughts and is based on some knowledge of DDD and application architecture. If you are not thorough with the domain knowledge, some parts may appear abrupt or you might not comprehend what I am trying to convey in the article
If time permits, you can read the books, Domain-Driven Design and Clean Architecture to get some preliminary knowledge. | https://alibaba-cloud.medium.com/how-to-code-complex-applications-core-java-technology-and-architecture-ed5acba1e34f | CC-MAIN-2021-10 | en | refinedweb |
First time here? Check out the FAQ!
This command is for Xen only:...
The problem seems to be localized in the LBaaS namespace because when I spawn a VM with HAproxy & another with webserver, the HTTP requests are load balanced immediately.
It seems that if I change net.ipv4.vs.timeout_timewait value (which is at 15) to 5, it takes 5s to answer.
Hi, you should check if cinder.conf has good informations to connect to the Cinder database.
And also check if the database already exists, and if the user is allowed to access to it.
You can see TCPdump here :
I'm trying to run the AutoScaling stack with this CFN template.
The Heat Stack is created and VM spawned but HAproxy inside the LoadBalancer VM fails to run correctly. It loads then fails, reload and refails.
HAproxy configuration (generated by CFN) /var/log/messages
I've tried both Fedora 17 & 18 and I've checked the version of HAproxy which is the last stable release (1.4.23).
My environment is a fresh OpenStack setup with Grizzly 2013.1.2 release.
Is anyone able to reproduce the bug ? Any thoughts ?
In advance, thank's for support.
You can find help here.
Cheers !
OpenStack is a trademark of OpenStack Foundation. This site is powered by Askbot. (GPLv3 or later; source). Content on this site is licensed under a CC-BY 3.0 license. | https://ask.openstack.org/en/users/68/emilien-macchi/?sort=recent | CC-MAIN-2021-10 | en | refinedweb |
Like many bioinformatic researchers, I’m a self-taught programmer and realized the role of programming testing only years later. Recently, I started to look into testing as my projects grew in sizes and dependencies. Some quick search led to Test-Driven Development, but this strict framework turned out unsuitable for my research projects, full of trials and errors. To find suitable testing solutions for programming in exploratory research, I did more specific readings. This blog will focus on testing research projects especially data science and machine learning applications. As this blog is based on my limited readings, do suggest me new resources if you feel any.
TL; DR:
1. Testing is crucial for debugging and maintaining codes
2. Implement test based on your needs and do it incrementally.
3. Test by Laws.
4. Use validation data sets.
- Some backgrounds on programming testing
Testing is crucial for debugging and maintaining programs. It is prevalently used in software engineering. Many bioinformatic researchers are aware of testing or even have implemented testing during programming classes, but many stop there. Additionally, popular packages are mostly well tested and even initial-stage research projects can benefit from testing. As Hadley Wickham mentioned in the package testthat, testing can largely speed up debugging, refactoring, and maintenance. It increases confidences when adding new modifications. Test cases are often good usage examples as well.
At the same time, there are considerable resources available to facilitate easier testing. Frameworks exist in R (testthat) and Python (pytest and unittest ) to simplify testing. Services like Travis CI have been broadly used to automate testing. Many published packages (e.g. stringr, scikit-learn and PyTorch) are thoroughly tested.
2. Why not just implement testing all the time?
Even though testing is broadly implemented and helpful, it does cost time. Most research projects are at early stage with the goal of exploration rather than stable implementation (like popular published packages). At this exploration stage, extensive testing can be a waste of time, especially when decision needs to be made promptly based on general patterns. Exploratory data analysis (EDA) is one major part at this early stage, where general statistics are calculated and visualized. A few different statical modeling approaches might also be tested informally, and most proposals do fail. As EDA is meant to give a quick, cheap, and less stringent view, testing might not provide good benefits over costs trade-offs. Many EDA codes actually won’t be used for the second time, for which testing might become wasting. Similarly, for those researchers who only use existing statistical tools (like SVM in scikit-learn) rather than implementing new tools, there seems little need for testing. There is also little benefit to test plotting functions.
However, testing can be super crucial when the projects expand, and the solutions need to be reused. Some researchers might convert functions into another language (refactoring), add new arguments on existing methods, or construct the implementation from mathematical descriptions. Testing is crucial for those cases, but the trade-off is still relevant. The researchers still need to make the difficult decision on where and how much to test. While really comprehensive testing looks good, it is often beyond the capability of the few authors. The following section will cover some testing solutions that reoccurs in public projects.
3. How to start test your data science codes
Functions in data science, statistics, and machine learning definitely need testing. However, there is specific difficulties in testing statistical programs (link). Possible outcomes in statistical methods are explosive and depends on the specific input data. Without running the function to be tested, it is often hard to know the result (test expectation) efficiently. While testing is possible for a few cases (predefined or random), it’s often hard to cover the most. Additionally, correct and well-tested functions are only halfway to success in data science projects, and hyper-parameter tuning and data preprocessing are also crucial. Discussion on proper machine learning skills is beyond this blog, and the following part will focus on testing solutions for the programs.
3.1 Test the Law rather than the output itself. Testing is often about the behavior of the function (the outputs based on given inputs). However, statistical methods often have explosive possibilities, and the output often cannot be obtained in obvious way. Hence, one alternative approach is to test things that hold true (Law) about the output rather than the output itself (link). This includes probabilities laws (0 ≤ Pᵢ≤ 1 and ∑Pᵢ=1) and known mathematical relationships between multiple outputs of the specific method. Careful reading of the original mathematic and statistic papers can help find some such Laws.
3.2 Include validation data set and baseline program. Small simulated or real-world datasets (e.g. iris) are often used in testing for sanity check and performance evaluation. Specific expectation for output might exist for a small simple dataset (see the last example in PCA function), but this is often not the case for real-world datasets. In this case, different internal implementations of the same method are expected to have similar outputs and can be cross-checked (the second last example in PCA function). Besides sanity check, performance can also be evaluated for the new function. By comparing with baseline program on the benchmark dataset, performance improvement can be presented. Unexpected behaviors seen in this comparison can also indicate possible bugs.
3.3 Treat adding testing as a process. It’s difficult to have relatively complete list of testing cases even for a simple function (e.g. PCA) in the beginning. Hence, it’s beneficial to treat testing as a process rather than a result. This is the case for scikit-learn as testing for PCA is being updated from 2011 till 2020 (link). In practice, this means adding testing when fixing bugs (and issues), adding new features, and involving community efforts (partly indicated by the number of contributors 16 for _pca.py 36 for test_pca.py). Even though there are considerable possibilities for testing your program, do have a plan and start from the most important ones.
3.4 There are many other approaches on testing. New neural network implementation can be tested through expectation on variable variation (link1 and link2). Functions on data transformation can be tested in relative determined perspectives, including dimensions, classes, and values. Extreme cases and expected failure can both be tested.
4. Examples
Here I go through some testing examples in published packages and explain concepts mentioned above.
4.1. Testing for str_detect in stringr package
str_detect is a string manipulation function and returns Boolean values indicating whether the input strings are matched by the given patterns. It is a common transformation step in my cleaning and preprocessing pipeline. stringr is a popular R package for common string manipulation, where easy-to-use functions like
str_detect are provided. These string manipulation functions are, however, relatively easier to test than statistical ones as expected behaviors can be easily determined. For a given string, a programmer can easily conclude whether it matched with a given regex.
test_that("special cases are correct", {
expect_equal(str_detect(NA, "x"), NA)
expect_equal(str_detect(character(), "x"), logical())
})
test_that("vectorised patterns work", {
expect_equal(str_detect("ab", c("a", "b", "c")), c(T, T, F))
expect_equal(str_detect(c("ca", "ab"), c("a", "c")), c(T, F))
# negation works
expect_equal(str_detect("ab", c("a", "b", "c"), negate = TRUE), c(F, F, T))
})
This example contains two tests and within each, there are multiple expectations. Each test is related to one specific functional case and each expectation is related to one return.
The first test is about clean behaviors for special/extreme input cases. When input string is
NA (empty character), the output should be
NA (empty logical types). Ensuring these behaviors is beneficial for constructing and debugging pipelines. Additionally, the test is implemented regarding behavior and without relying on the internal function mechanisms.
The second test is about vectorization, a useful technique in R, that the function will work in similar way for both single value and vector as inputs. Vectorization is especially useful for speeding up workflows in R. Multiple possible usage cases are presented as expectations[1]. If
negate=true, the output will be negated. It can also be seen that both tests use simple representative examples without going through more comprehensive cases.
4.2. Testing for PCA function in scikit-learn
scikit-learn is a popular python package for machine learning analysis. It is well documented and tested. PCA tries to find latent variables that explain maximal amount of variance iteratively. It is prevalently used for EDA, visualization, and features extraction (Details). Such a function is extensively tested (link). PCA has multiple internal implementations and each one contains multistep numeric computation. As a statistic method, the output of PCA depends on the input and it is difficult to write down the output given any arbitrary input. Here a few testing examples are presented.
@pytest.mark.parametrize('svd_solver', PCA_SOLVERS)
@pytest.mark.parametrize('n_components', range(1, iris.data.shape[1]))
def test_pca(svd_solver, n_components):
X = iris.data
pca = PCA(n_components=n_components, svd_solver=svd_solver)
# check the shape of fit.transform
X_r = pca.fit(X).transform(X)
assert X_r.shape[1] == n_components
# check the equivalence of fit.transform and fit_transform
X_r2 = pca.fit_transform(X)
assert_allclose(X_r, X_r2)
X_r = pca.transform(X)
assert_allclose(X_r, X_r2)
# Test get_covariance and get_precision
cov = pca.get_covariance()
precision = pca.get_precision()
assert_allclose(np.dot(cov, precision), np.eye(X.shape[1]), atol=1e-12)
Similar to
testhat in R, in
pytest each test contains multiple expectations (assertations). In the beginning,
@pytest.mark.parametrize enable testing to loop through different arguments: different SVD solvers and predefined numbers of components.
assert_allclose is similar to
expect_equal in
testhat, though the values are compared within some tolerance ranges. This is crucial as numeric computation can introduce small and irrelevant deviations.
This is the first test in test_pca.py, and multiple expectations based on a validation dataset (iris) are checked. First, it tests the dimension of the output to be the same as expected: the set number of components. Second, it tests the agreement between two ways of analysis: fit the model then transform the data and do both in one step. Last, a Law is tested: given input data, the dot product of covariance and precision should be identity matrix.
@pytest.mark.parametrize('svd_solver', ['arpack', 'randomized'])
def test_pca_explained_variance_equivalence_solver(svd_solver):
rng = np.random.RandomState(0)
n_samples, n_features = 100, 80
X = rng.randn(n_samples, n_features)
pca_full = PCA(n_components=2, svd_solver='full')
pca_other = PCA(n_components=2, svd_solver=svd_solver, random_state=0)
pca_full.fit(X)
pca_other.fit(X)
assert_allclose(
pca_full.explained_variance_,
pca_other.explained_variance_,
rtol=5e-2
)
assert_allclose(
pca_full.explained_variance_ratio_,
pca_other.explained_variance_ratio_,
rtol=5e-2
)
Here is a test about consistency among different implementations (SVD solvers). Explained variance and corresponding ratio is calculated with different solvers and compared with the results from option
‘full’. Random generated data is used for this test. Even though this argument can often be wisely (automatically) chosen in real world, different options should produce similar results.
@pytest.mark.parametrize("svd_solver", PCA_SOLVERS)
def test_pca_check_projection_list(svd_solver):
# Test that the projection of data is correct
X = [[1.0, 0.0], [0.0, 1.0]]
pca = PCA(n_components=1, svd_solver=svd_solver, random_state=0)
X_trans = pca.fit_transform(X)
assert X_trans.shape, (2, 1)
assert_allclose(X_trans.mean(), 0.00, atol=1e-12)
assert_allclose(X_trans.std(), 0.71, rtol=5e-3)
In this test, a super regular input matrix is supplied and so, there is theoretical expectation about the result: for the transformed matrix, mean equals 0 and standard deviation equals 0.71 approximately. This case is rare but useful for checking correct mathematical implementation. Agreement with formula can be reassuring even though the real-world dataset is often far more complex.
Some key take-aways:
1. Testing is crucial for debugging and maintaining codes
2. Implement test based on your needs and do it incrementally.
3. Test by Laws.
4. Use validation data sets.
Notes:
- If
length(string)==1and
length(pattern)>1, then function will loop though all different patterns for the same string. If both inputs are vectors, then they need to be the same length and the result will be based on pairwise match.
Acknowledgement: Thanks the great comments from Michael Judge and Marcus Hill
References: | https://yuewu-mike.medium.com/a-random-walk-in-testing-research-programs-6b60acaa3066?source=post_internal_links---------4---------------------------- | CC-MAIN-2021-10 | en | refinedweb |
Technical Support
Support Resources
Product Information
Information in this article applies to:
The GNU Linker gives error messages while linking an application,
which contains class declarations and class instances.
The class declaration specifies a constructor and/or destructor,
but the constructor/destructor function is missing.
class clf {
public:
clf(); // Constructor (ctor)
~clf(); // Destructor (dtor)
int n1, n2, n3;
};
clf clf1; // class object
int main (void) {
return (0);
}
The Linker gives the error messages which look like the following
ones:
.\obj\blinky.o(.text+0x40): In function '__static_initialization_and_destruction_0':
/cygdrive/c/Keil/ARM/GNU/Examples/Blinky/blinky.cpp(92):
error: undefined reference to 'clf::~clf [in-charge]() 'blinky.o'
(.text+0x44):blinky.cpp:92: undefined reference to 'clf::clf[in-charge]()'
Add the constructor(s) and/or destructor(s) as shown below:
class clf {
public:
clf(); // Constructor (ctor)
~clf(); // Destructor (dtor)
int n1, n2, n3;
};
clf::clf () { // define ctor
n1 = n2 = n3 = 0;
}
clf::~clf() { // define dtor
}
clf clf1; // class object
int main (void) {
return (0);
}
Last Reviewed: Monday, January 4, 2021. | https://www.keil.com/support/docs/3136/ | CC-MAIN-2021-10 | en | refinedweb |
Introduction
Proxy Pattern provides a surrogate or placeholder for another object to control access to it. In Proxy Pattern, we create object (proxy) having original object (real) to interface its functionality to outer world.
Proxy Pattern is classified into structural patterns category.
There are three roles in Proxy Pattern :
- Subject: Interface class that defines operations and tasks
- Real Subject: concrete class that DO REAL operations and tasks
- Proxy Subject: Proxy class that performs the REAL operations and tasks on behalf of a Real Subject.
Sample structure of Proxy pattern:
Exercise of my anecdote
Once upon a time, my girlfriend and I were separated in two different countries for several months. Then I wanted to give a gift to her for her upcoming birthday. So I bought a gift on line and sent it to one of our common friends. This friend then handed it to my girlfriend along with a card with my message printed on it.
So I would like to do a simple exercise to simulate this anecdote of mine. For the sake of privacy, I use Romeo and Julia to replace the real names in this story :D.
Simulation
Now I start to code for simulating the following scenario: Romeo gave rose directly to Julia, and he asked Jack to give a chocolate to Julia in his behalf.
Firstly define classes of the three roles of Proxy Pattern.
from abc import ABCMeta, abstractmethod class Subject(metaclass=ABCMeta): """ Subject class """ def __init__(self, name): self.__name = name def getName(self): return self.__name @abstractmethod def request(self, content = ''): pass class RealSubject(Subject): """RealSubject class""" def request(self, content): print("RealSubject todo something...") class ProxySubject(Subject): """ ProxySubject Class""" def __init__(self, name, subject): super().__init__(name) self._realSubject = subject def request(self, content = ''): self.preRequest() if(self._realSubject is not None): self._realSubject.request(content) self.afterRequest() def preRequest(self): print("preRequest") def afterRequest(self): print("afterRequest") class RomeoGiving(Subject): """Romeo gives gift""" def __init__(self, name, wishMsg, receiver): super().__init__(name) self.__message = wishMsg self.__receiver = receiver def getMsg(self): return self.__message def getReceiver(self): return self.__receiver def request(self, content): print(" {} sends gift to {} with a wish Message：\"{}\"" .format(self.getName(), self.getReceiver(), self.getMsg())) print(" Gift is {}".format( str(content)) ) class JackGiving(ProxySubject): """Jack gives gift instead""" def __init__(self, name, GivingTask): super().__init__(name, GivingTask) def preRequest(self): print(" [Proxy] {} saying: I give you the gift on behalf of {}".format(self.getName(), self._realSubject.getName() )) def afterRequest(self): print(" [Proxy] {} saying: I have given gift to {} on behalf of {}" .format(self.getName(), self._realSubject.getReceiver(), self._realSubject.getName() ))
Now launch the simulation:
if __name__ == '__main__': print("=================" ) Romeo = RomeoGiving("Romeo", "I loved you, I love you and I will love you forever.", "Julia") print("Romeo gives gift: ") Romeo.request("Rose") print("=================" ) print("Jack gives gift instead") Jack = JackGiving("Jack", Romeo) Jack.request("Chocolate")
Simulation execution output:
Discussion (0) | https://dev.to/jemaloqiu/design-pattern-in-python-5-proxy-pattern-44mf | CC-MAIN-2021-10 | en | refinedweb |
approximate nonlinear FEM elements with simplices More...
#include <vtkTessellatorFilter.h>
approximate nonlinear FEM elements with simplices
This class approximates nonlinear FEM elements with linear simplices.
Warning: This class is temporary and will go away at some point after ParaView 1.4.0.
This filter rifles through all the cells in an input vtkDataSet. It tesselates each cell and uses the vtkStreamingTessellator and vtkDataSetEdgeSubdivisionCriterion classes to generate simplices that approximate the nonlinear mesh using some approximation metric (encoded in the particular vtkDataSetEdgeSubdivisionCriterion::EvaluateLocationAndFields implementation). The simplices are placed into the filter's output vtkDataSet object by the callback routines AddATetrahedron, AddATriangle, and AddALine, which are registered with the triangulator.
The output mesh will have geometry and any fields specified as attributes in the input mesh's point data. The attribute's copy flags are honored, except for normals.
Definition at line 68 of file vtkTessellatorFilter.h.
Definition at line 71 of file vtkTessellatorFilter.
Set the dimension of the output tessellation.
Cells in dimensions higher than the given value will have their boundaries of dimension OutputDimension tessellated. For example, if OutputDimension is 2, a hexahedron's quadrilateral faces would be tessellated rather than its interior.
Definition at line 194 of file vtkTessellatorFilter.h.
These are convenience routines for setting properties maintained by the tessellator and subdivider.
They are implemented here for ParaView's sake.
These methods are for the ParaView client.
The adaptive tessellation will output vertices that are not shared among cells, even where they should be.
This can be corrected to some extents with a vtkMergeFilter. By default, the filter is off and vertices will not be shared.
Fill the input port information objects for this algorithm.
This is invoked by the first call to GetInputPortInformation for each port so subclasses can specify what they can handle.
Reimplemented from vtkUnstructuredGridAlgorithm.
Called by RequestData to set up a multitude of member variables used by the per-primitive output functions (OutputLine, OutputTriangle, and maybe one day...
OutputTetrahedron).
Called by RequestData to merge output points.
Reset the temporary variables used during the filter's RequestData() method.
Run the filter; produce a polygonal approximation to the grid.
Reimplemented from vtkUnstructuredGridAlgorithm.
Definition at line 160 of file vtkTessellatorFilter.h.
Definition at line 161 of file vtkTessellatorFilter.h.
Definition at line 162 of file vtkTessellatorFilter.h.
Definition at line 163 of file vtkTessellatorFilter.h.
Definition at line 164 of file vtkTessellatorFilter.h.
These member variables are set by SetupOutput for use inside the callback members OutputLine and OutputTriangle.
Definition at line 171 of file vtkTessellatorFilter.h.
Definition at line 172 of file vtkTessellatorFilter.h.
Definition at line 173 of file vtkTessellatorFilter.h.
Definition at line 174 of file vtkTessellatorFilter.h. | https://vtk.org/doc/nightly/html/classvtkTessellatorFilter.html | CC-MAIN-2021-10 | en | refinedweb |
Correct UART pins and problems
I've been trying to get a Honeywell HPMA115S0 particulate sensor working with my LoPy4 and expansion board, but even with a modified Python library and lots of trial and error, it still can't read anything (the sensor works fine with a Pi). I want to check which pins I should be using for UART, and if there are any known issues that'd explain the problems I'm having.
LoPy4 with the latest firmware, expansion board 2.0, USB connected, sensor connected to VIN (it uses 5V power and 3V logic), have tried a variety of pins but it seems like G24 and G11 should be the right ones.
@hopkapi If you connect
G24 aka P3 -> 7
G11 aka P4 -> 6
GND -> 8 GND
Vin -> 2 (5V)
and run the LoPy from USB. then the electrical conditions shoul be OK, and the device shoudl be accessible via UART 1. SOmetimes the definition of Tx and Rx are reversed, so you may swap P3 and P4. That should not cause any harm to the devices. The UART setting according to the data sheet is baud rate: 9600, databits: 8, stopbits: 1, parity: no
Some test code would be like:
from machine import UART uart = UART(1, 9600) # init with given baudrate uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters while True: data = uart.readall() if data is not None: print(data)
This post is deleted! | https://forum.pycom.io/topic/3467/correct-uart-pins-and-problems | CC-MAIN-2021-10 | en | refinedweb |
Tell us what you think of the site.
I am relatively new to python in mobu and am trying to change attributes of a certain camera via python. Specifically the Focal Length and toggling items such as Title Safe and the grid.
What i can’t figure out is how to select a camera based on its name and then proceed to change its attributes.
Any suggestions?
Thanks!
Hi,
here is a quick example how to get access to the cameras in your mobu-scene:
from pyfbsdk import *
# we are getting an object instance of the whole scenemyScene = FBSystem().Scene
# we know that myScene.Cameras is a list of objects, the cameras
# Therefore we iterate through this list by every object and print out the namefor obj in myScene.Cameras:
print obj.Name
This is a very simple way to get any information about your scene. Look up “FBScene” in the Mobu SDK Help(Mobu-Menu->Help->Motionbuilder SDK Help). There you can find any other attributes or functions this class holds or can execute if it is instanced as an object we have access to via python.
If you look for FBCamera(the camera object class) you will find a huge amount of camera attributes you can reach, e.g. FocalLength. :)
If we add this knowledge to our little script:
from pyfbsdk import *
myScene = FBSystem().Scene
for obj in myScene.Cameras:
#prints out the name
print obj.Name
#prints out the FocalLength
print obj.FocalLength
That’s it for the start. :)
Cheers,
Chris | http://area.autodesk.com/forum/autodesk-motionbuilder/python/change-camera-attributes-via-python/ | crawl-003 | en | refinedweb |
Tell us what you think of the site.
Hi
Is there a way to automatically import custom made module in motion builder.
Thanks
What you call by module ?
well im in a Python forum so im talking about a python script in which there are defs that i can call to simplify the python commands
ex:
in my script (module) defs.py
from pyfbsdk import FBModelList,FBGetSelectedModels
def selection():
modelList = FBModelList()
FBGetSelectedModels( modelList )
if len(modelList) == 0:
return None
else:
return modelList
if i type in the python console
from defs import *
i can then type selection() and get what is selected
The weird thing about motion builder is that it DOES import my “defs” module at startup but it doesnt keep it in the globals() of the python shell.
any solution to that
well I like to be sure before I answer. Hope it didn’t offend you.
I have check and it looks like that import is hard coded in MB python console.
Cheers
so in other words there is nothing i can do…
Same problem here…
I want to transfer a shelf-like UI tool to Motionbuilder 2012. Every tab is a separate module, but I run in the same problem as Pierre-Marc.
By the way, I got the code from an example by Naiqi Weng last week during an Autodesk class, so there must be a way to make that work.
Well, it seems Mobu 2012 wants us to put our modules here:
C:\Program Files (x86)\Autodesk\MotionBuilder 2012 (32-bit)\bin\config\Python
instead of
C:\Users\jsimard\Documents\MB\2012\config\Python
It works now.
Damned refresh… | http://area.autodesk.com/forum/autodesk-motionbuilder/python/auto-import-module/page-last/ | crawl-003 | en | refinedweb |
We.
The goal of most security attacks is to gain unauthorized access to a
computer system by taking control of a vulnerable privileged program.
This is done by exploiting bugs that allow overwriting stored program
addresses with pointers to malicious code. Today's most prevalent
attacks target buffer overflow and format string vulnerabilities.
However, it is very difficult to prevent all exploits that allow address
overwrites, as they are as varied as program bugs themselves. It is
also unreasonable to try to stop malevolent writes to memory containing
program addresses, because addresses are stored in many different places
and are legitimately manipulated by the application, compiler, linker,
and loader.
Security attacks cannot be thwarted by simply inserting checks around
application code that may cause system-wide changes. A malicious entity
that gains control can simply inject its own code to perform any
operation that the overall application has permission to do. Hijacking
trusted applications such as web servers, mail transfer agents, and
login servers, which are typically run with many global permissions,
gives full access to machine resources.
Rather than attempt to stop a multitude of attack paths, where the
protection is only as powerful as the weakest link, our approach is to
prevent the execution of malicious code. We present program
shepherding - monitoring control flow transfers to enforce a security
policy. Program shepherding prevents execution of data or modified code
and ensures that libraries are entered only through exported entry
points. Instead of focusing on preventing memory corruption, we prevent
the final step of an attack, the transfer of control to malevolent code.
This allows thwarting a broad range of security exploits with a simple
central system that can itself be easily made secure. Program
shepherding also provides sandboxing that cannot be circumvented,
allowing construction of customized security policies.
Program shepherding requires verifying every branch instruction, which
is not easily done via static instrumentation due to the dynamism of
shared libraries and indirect branches. Implementation in an
interpreter is the most straightforward solution. We reduce the
overhead of interpretation by performing security checks once and
placing the resulting trusted code in a cache, where it can be executed
overhead-free in the future. Our implementation naturally fits within
the RIO infrastructure, a dynamic optimizer built on the IA-32
version [3] of Dynamo [2]. The resulting system
imposes minimal or no performance overhead, operates on unmodified
native binaries, and requires no special hardware or operating system
support. Our shepherding implementation on top of RIO is implemented
for both Windows and Linux; however, this paper mainly focuses on Linux.
In Section 2 we classify the types of security exploits
that we are aiming to prevent. Program shepherding's three techniques
are described in Section 3, and
Section 4 shows how to combine them to produce potent
security policies. Section 5 discusses how we
implement program shepherding efficiently, and Section 6
describes how to prevent attacks directed at our system itself. We
present experimental results and the performance of our system in
Section 7.
This section provides some background on the types of security exploits
we are targeting. We classify security exploits based on three
characteristics: the program vulnerability being exploited, the stored
program address being overwritten, and the malicious code that is then
executed.
The two most-exploited classes of program bugs involve buffer overflows
and format strings. Buffer overflow vulnerabilities are present when a
buffer with weak or no bounds checking is populated with user supplied
data. A trivial example is unsafe use of the C library functions
strcpy or gets. This allows an attacker to corrupt adjacent
structures containing program addresses, most often return addresses
kept on the stack [7]. Buffer overflows affecting
a regular data pointer can actually have a more disastrous effect by
allowing a memory write to an arbitrary location on a subsequent use of
that data pointer. One particular attack corrupts the fields of a
double-linked free list kept in the headers of malloc allocation
units [16]. On a subsequent call to free, the list update
operation this->prev->next = this->next;
will modify an arbitrary location with an arbitrary value.
Format string vulnerabilities also allow attackers to modify arbitrary
memory locations with arbitrary values and often out-rank buffer
overflows in recent security
bulletins [6,19]. A format string
vulnerability occurs if the format string to a function from the
printf family ({,f,s,sn}printf, syslog)
is provided or
constructed from data from an outside source. The most common case is
when printf(str) is used instead of printf("%s",str). The
first problem is that attackers may introduce conversion
specifications to enable them to read the memory contents of
the process. The real danger, however, comes from the
%n conversion specification which directs the number of
characters printed so far to be written back. The location where the
number is stored and its value
can easily be controlled by an attacker with type and width specifications,
and more than one write of an arbitrary value to an arbitrary address
can be performed in a single attack.
In this paper we assume that attackers can exploit a vulnerability that
gives them random write access to arbitrary addresses in the program
address space. This ability can be used to overwrite any stored program
address to transfer control of the process to the attacker.
Many entities participate in transferring control in a program
execution. Compilers, linkers, loaders, runtime systems, and
hand-crafted assembly code all have legitimate reasons to transfer
control. Program addresses are credibly manipulated by most of these
entities, e.g., dynamic loaders patch shared object functions; dynamic
linkers update relocation tables; and language runtime systems modify
dynamic dispatch tables.
Generally, these program addresses are intermingled with and
indistinguishable from data. In such an environment, preventing a
control transfer to malicious code by stopping illegitimate memory
writes is next to impossible. It requires the cooperation of numerous
trusted and untrusted entities that need to check many different
conditions and understand high-level semantics in a complex environment.
Security exploits can attack program addresses stored in many
different places. Buffer overflow attacks target addresses adjacent
to the vulnerable buffer. The classic return address attacks and
local function pointer attacks exploit overflows of stack allocated
buffers. Global data and heap buffer overflows also allow global
function pointer attacks and setjmp structure attacks.
Data pointer buffer overflows, malloc overflow attacks, and
%n format string attacks are able to modify any stored program
address in the vulnerable application - in addition to the
aforementioned addresses, these attacks target entries in the
atexit list, .dtors destructor routines, and in the Global
Offset Table (GOT) [12] of shared object entries.
An attacker can cause damage with injection of new malicious code or by
malicious reuse of already present code. Usually the first approach is
taken and the attack code is implemented as new native code that is
injected in the program address space as data [20]. New code
can be injected into various areas of the address space: in a stack
buffer, static data segment, near or far heap buffer,
or even the Global Offset Table. Since normally there is no distinction
between read and execute privileges for memory pages (this is the case
for IA-32), the only requirement is that the pages are writable during
the injection phase. Modifying any stored program address to point to
the beginning of the introduced code will trigger intrusion when that
address is used for control transfer.
It is also possible to reuse existing code by changing a stored
program address and constructing an activation record with suitable
arguments. A simple but powerful attack reuses existing code by
changing a function pointer to the C library function system,
and arranges the first argument to be an arbitrary shell command to be
run. Also note that reuse of existing code can include jumping into
the middle of a sandboxed operation, bypassing the sandboxing checks
and executing the operation that was intended to be protected. In
addition, a jump into the middle of an instruction (on IA-32
instructions are variable-sized and unaligned) could cause execution
of an unintended and possibly malicious instruction stream; however,
such an attack is very unlikely.
An attacker may be able to form higher-level malicious code by
introducing data carefully arranged as a chain of activation records,
so that on return from each function execution continues in the next
function of the chain [18]. The prepared activation
record return address points to the code in a function epilogue that
shifts the stack pointer to the following activation record and
continues execution in the next function. Overwriting a suitable
sequence of function pointers may also produce higher-level malicious
code.
The program shepherding approach to preventing execution of malicious
code is to monitor all control transfers to ensure that each satisfies a
given security policy. This allows us to ignore the complexities of
various vulnerabilities and the difficulties in preventing illegitimate
writes to stored program addresses. Instead, we catch a large class of
security attacks by preventing execution of malevolent code. We do this
by employing three techniques: restricted code origins, restricted
control transfers, and un-circumventable sandboxing. This section
describes these techniques, while Section 4 discusses
how to build security policies using these techniques.
In monitoring all code that is executed, each instruction's origins are
checked against a security policy to see if it should be given execute
privileges. Code origins are classified into these categories: from the
original image on disk and unmodified, dynamically generated but
unmodified since generation, and code that has been modified. Finer
distinctions could also be made. We describe in
Section 5.3 how to distinguish original code from modified
and possibly malicious code.
A hardware execute flag for memory pages can provide similar features to
our restricted code origins. However, it cannot by itself duplicate
program shepherding's features because it cannot stop inadvertent or
malicious changes to protection flags. Program shepherding uses
un-circumventable sandboxing, described in Section 3.3, to
prevent this from happening. Furthermore, program
shepherding provides more than one bit of privilege information: it
distinguishes different types of execute privileges for which different
security policies may be specified.
Program shepherding allows arbitrary restrictions to be placed on
control transfers in an efficient manner. These restrictions can be
based on both the source.
Program shepherding provides direct support for restricting code origins
and control transfers. Execution can be restricted in other ways by
adding sandboxing checks on other types of operations. (see Section 6).
Program shepherding's three techniques can be used to provide powerful
security guarantees. They allow us to strictly enforce a safe subset of
the instruction set architecture and the operating system interface.
There are tradeoffs between program freedom and security: if
restrictions are too strict, many false alarms will result when there is
no actual intrusion.
This section discusses the potential design space of security policies
that provide significant protection for reasonable restrictions of
program freedom. We envision a system with customizable policy
settings; however, our current system implements a single security
policy, which is described later in this section.
Table 1 lists sample policy decisions that can be
implemented with program shepherding. Consider the policy decision in
the upper right of the table: allowing unrestricted execution of code
only if it is from the original application or library image on disk and
is unmodified. Such a policy will allow the vast majority of programs
to execute normally. Yet the policy can stop all security exploits that
inject code masquerading as data into a program. This covers a majority
of currently deployed security attacks, including the classic stack
buffer overflow attack.
A relaxation of this policy allows dynamically generated code, but requires
that it contain no system calls. Legitimate dynamically-generated
code is usually used for performance; for example, many high-level
languages employ just-in-time compilation [1,11]
to generate optimized pieces of code that will be executed natively
rather than interpreted. This code almost never contains system calls
or other potentially dangerous operations. For this reason, imposing a
strict security policy on dynamically-generated code is a reasonable
approach. Shared libraries that are explicitly loaded (i.e., with
dlopen or LoadLibrary) and dynamically selected based on
user input should also be considered potentially unsafe. Similarly,
self-modifying code should usually be disallowed, but may be
explicitly allowed for certain applications.
Direct control transfers that satisfy the code origin policies can
always be allowed within a segment. Calls and jumps that transition
from one executable segment to another, e.g., from application code to a
shared library, or from one shared library to another, can be restricted
to enforce library interfaces. Targets of inter-segment calls and jumps
can be verified against the export list of the target library and the
import list of the source segment, in order to prevent malevolent jumps
into the middle of library routines.
Indirect control transfers can be carefully limited. The calling
convention can be enforced by preventing return instructions from
targeting non-call sites, and limiting direct call sites to be the
target of at most one return site. Controlling return targets severely
restricts exploits that overwrite return addresses, as well as
opportunities for stitching together fragments of existing code in an
attack.
Indirect calls can be completely disallowed in many applications. Less
restrictive general policies are needed, but they require higher-level
information and/or compiler support. For C++ code it is possible to
keep read-only virtual method tables and allow indirect calls using
targets from these areas only. However, further relaxations are needed
to allow callback routines in C programs. A policy that provides a
general solution requires compiler support, profiling runs, or other
external sources of information to determine all valid indirect call
targets. A more relaxed policy restricts indirect calls from libraries
no more than direct calls are restricted (if between segments they can
only target import and export entries), while calls within the
application text segment can target only intra-segment function entry
points. The requirement of function entry points beyond a simple
intra-segment requirement prevents indirect calls from targeting direct
calls or indirect jumps that validly cross executable segment points and
thus avoid the restriction. It is possible to extract the valid user
program entry points from the symbol tables of unstripped binaries.
Unfortunately, stripped binaries do not keep that information.
Indirect jumps are used in the implementation of switch statements
and dynamically shared libraries. The first use can easily be allowed
when targets are validated to be coming from read-only memory and are
hence trusted. The second use, shared library calls, should be allowed,
but such inter-segment indirect jumps can be restricted to library
entry points. These restrictions will not allow an indirect jump
instruction that is used as a function return in place of an actual
return instruction.
However, we have yet to see such code. It will certainly not be
generated by compilers since it breaks important hardware optimizations
in modern IA-32 processors [21].
Sandboxing can provide detection of attacks that get past other
barriers. For example, an attack that overwrites the argument passed to
the system routine may not be stopped by any aforementioned
policy. Program shepherding's guaranteed sandboxing can be used for
intrusion detection for this and other attacks. The security policy
must decide what to check for (for example, suspicious calls to system
calls like execve) and what to do when an intrusion is actually
detected. These issues are beyond the scope of this paper, but have
been discussed elsewhere [15,17].
Sandboxing with checks around every load and store could be used to
ensure that only certain memory regions are accessed during execution of
untrusted code segments. This would provide significant security but at
great expense in performance.
We now turn our attention to a specific security policy made up of the
bold entries in Table 1. We implemented this policy in
our prototype system. For this security policy,
Figure 1 summarizes the contribution of each program
shepherding technique toward stopping the types of attacks described in
Section 2. The following sections describe in detail
which policy components are sufficient to stop each attack type.
The code origin policy disallows execution from address ranges other
than the text pages of the binary and mapped shared libraries. This
stops all exploits that introduce external code, which covers a majority
of currently deployed security attacks. However, code origin checks are
insufficient to thwart attacks that change a target address pointer to
point to existing code in the program address space.
Most vulnerable programs are unlikely to have code that could be
maliciously used by an attacker. However, all of them have the standard
C library mapped into their address space. The restrictions on
inter-segment control transfers limit the available code that can be
attacked to that explicitly declared for use by the application. Still,
many of the large programs import the library routines a simple attack
needs. For this reason, restricting inter-segment transitions to imported
entry points would stop only a few attacks.
Return address attacks, however, are severely limited: they may only
target code following previously executed call instructions. A further
restriction can easily be provided by using restricted control transfers
to emulate a technique proposed in
StackGhost [14]. A random number can be
xor-ed with the return address stored on the stack after a call and
before a return. Any modification of the return address will result
with very high probability in a request for an invalid target. In a
threat model in which attackers can only write to memory, this technique
renders execution of the attacker's intended code very unlikely. This
protection comes at the low cost of two extra instructions per function
call, but its additional value is hard to determine due to the already
limited applicability of this kind of exploit. Furthermore, an
attacker able to exploit a vulnerability that provides random read
rights will not be stopped by this policy. Thus, we currently do not
impose it.
By single call attack we mean an attack that overwrites only a
single program address (perhaps overwriting non-address data as well),
thus resulting in a single malicious control transfer. We consider the
readily available execve system call to be the most vulnerable
point in a single-call attack. However, it is possible to construct an
intrusion detection predicate [17] to distinguish attacks
from valid execve calls, and either terminate the application or
drop privileges to limit the exposure. Since only a single call can be
executed, system calls that need to be used in combination for an
intrusion do not need to be sandboxed. Sandboxing execve also
prevents intrusion by an argument overwrite attack.
Nevertheless, sandboxing alone does not provide protection against
sequences of operations that an application is allowed to do and can be
controlled by an attacker. For example, an exploit that emulates the
normal behavior of sshd, i.e., listens on a network socket,
accepts a connection, reads the password file for authentication, but at
the end writes the password file contents to the network, cannot be
stopped by simple sandboxing. Therefore, restrictions on control
transfers are crucial to prevent construction of such higher-level
code from primitives, and hence to limiting possible attacks only to
data attacks targeting unlikely sequences of existing code.
An attacker may be able to execute a malicious code sequence by
carefully constructing a chain of activation records, so that on return
from each function execution continues in the next
one [18]. Requiring that return instructions target only
call sites is sufficient to thwart the chained call attack, even when
the needed functions are explicitly imported and allowed by
inter-segment restrictions. The chaining technique is countered because
of its reliance on return instructions: once to gain control at the end
of each existing function, and once in the code to shift to the
activation record for the next function call.
We were able to construct applications that were open to an exploit that
forms higher-level malicious code by changing the targets of a sequence
of function calls as well as their arguments. Multiple sequential
intrusions may also allow execution of higher-level malicious code.
Higher-level semantic information is needed to thwart these attacks' intrusion
method by limiting the valid indirect call targets. The policy that is
able to stop such attacks in general, and without any false alarms,
requires knowing in advance a list of bindings built on a previous run
or otherwise generated.
It is also possible to extract the valid user program entry points
from the symbol tables of unstripped binaries. Allowing indirect
calls to target only valid entry points within the executable and
within the shared libraries limits the targets for higher-level code
construction. If there are no simple wrappers in the executable that
allow arbitrary arguments to be passed to the lower level library
functions, the possibility of successful attack of this type will be
minimal.
Nevertheless, interpreters that are too permissive are still going to
be vulnerable to data attacks that may be used to form higher-level
malicious code that will not be recognized as a threat by these
techniques.
In order for a security system to be viable, it must be efficient.
And to be widely and easily adoptable, it must be transparent.
Transparency includes whether a target application must be recompiled
or instrumented and whether the security system requires special
hardware or operating system support. We examined possible
implementations of program shepherding in terms of these two
requirements of efficiency and transparency.
One possible method of monitoring control flow is instrumentation of
application and library code prior to execution to add security checks
around every branch instruction. Beyond the difficulties of statically
handling indirect branches and dynamically loaded libraries, the
introduced checks impose significant performance penalties.
Furthermore, an attacker aware of the instrumentation could design an
attack to overwrite or bypass the checks. Instrumentation is neither
very viable nor applicable.
Another possibility is to use an interpreter. Interpretation is a
natural way to monitor program execution because every application
operation is carried out by a central system in which security checks
can be placed. However, interpretation via emulation is slow,
especially on an architecture like IA-32 with a complex instruction
set, as shown in Table 2.
Recent advances in dynamic optimization have focused on low-overhead
methods for examining execution traces for the purpose of optimization.
This infrastructure provides the exact functionality needed for
efficient program shepherding. Dynamic optimizers begin with an
interpretation engine. To reduce the emulation overhead, native
translations of frequently executed code are cached so they can be
directly executed in the future.
For a security system, caching means
that many security checks need be performed only once, when the code is
copied to the cache. If the code cache is protected from malicious
modification, future executions of the trusted cached code proceed with
no security or emulation overhead.
We decided to build our program shepherding system as an extension to a
dynamic optimizer called RIO. RIO is built on top of the IA-32
version [3] of Dynamo [2]. RIO's optimizations
are still under development. However, this is not a hindrance for our
security purposes, as its performance is already reasonable (see
Section 7.2). RIO is implemented for both IA-32 Windows and
Linux, and is capable of running large desktop applications.
A flow chart showing the operation of RIO is presented in
Figure 2. The figure concentrates on the flow of
control in and out of the code cache, which is the bottom portion of the
figure. The copied application code looks just like the original code
with the exception of its control transfer instructions, which are shown
with arrows in the figure.
Below we give an overview of RIO's operation, focusing on the aspects
that are relevant to our implementation of program shepherding. The
techniques of program shepherding fit naturally within the RIO
infrastructure. Most monitoring operations only need to be performed
once, allowing us to achieve good performance in the steady-state of the
program. In our implementation, a performance-critical inner loop will
execute without a single additional instruction beyond the original
application code.
RIO copies basic blocks (sequences of instructions ending with a
single control transfer instruction) into a code cache and executes them
natively. At the end of each block the application's machine state must
be saved and control returned to RIO (a context switch) to copy
the next basic block. If a target basic block is already present in the
code cache, and is targeted via a direct branch, RIO links the two
blocks together with a direct jump. This avoids the cost of a subsequent context
switch.
Indirect branches cannot be linked in the same way because their targets
may vary. To maintain transparency, original program addresses must be used
wherever the application stores indirect branch targets (for example,
return addresses for function calls). These addresses must be
translated into their corresponding code cache addresses in order to
jump to the target code. This translation is performed as a fast
hashtable lookup.
To improve the efficiency of indirect branches, and to achieve better
code layout, basic blocks that are frequently executed in sequence are
stitched together into a unit called a trace. When connecting
beyond a basic block that ends in an indirect branch, a check is
inserted to ensure that the actual target of the branch will keep
execution on the trace. This check is much faster than the hashtable
lookup, but if the check fails the full lookup must be performed. The
superior code layout of traces goes a long way toward amortizing the
overhead of creating them and often speeds up the
program [2,24].
Table 2 shows the typical performance improvement of each
enhancement to the basic interpreter design. Caching is a dramatic
performance improvement, and adding direct links is nearly as dramatic.
The final steps of adding a fast in-cache lookup for indirect branches
and building traces improve the performance significantly as well.
The Windows operating system directly invokes application code or
changes the program counter for callbacks, exceptions, asynchronous
procedure calls, setjmp, and the SetThreadContext API
routine. These types of control flow are intercepted in order to
ensure that all application code is executed under RIO [3].
Signals on Linux must be similarly intercepted.
Restricting execution to trusted code is accomplished by adding checks
at the point where the system copies a basic block into the code cache.
These checks need be executed only once for each basic block.
Code origin checking requires that RIO know whether code has been
modified from its original image on disk, or whether it is dynamically
generated. This is done by write-protecting all pages that are declared
as containing code on program start-up. In normal ELF [12], we make a copy of the
page, which we write-protect, and then unprotect the original page. The
copy is then used as the source for basic blocks, while the original
page's data can be freely modified. A more complex scheme must be used
if self-modifying code is allowed. Here RIO must keep track of the
origins of every block in the code cache, invalidating a block when its
source page is modified. The original page must be kept write-protected
to detect every modification to it. The performance overhead of this
depends on how often writes are made to code pages, but we expect
self-modifying code to be rare. Extensive evaluation of applications
under both Linux and Windows has yet to reveal a use of self-modifying
code.
The dynamic optimization infrastructure makes monitoring control flow
transfers very simple. hashtable lookup routine translates the
target program address into a basic block entry address. A separate
hashtable is used for different types of indirect branch (return
instruction, indirect calls, and indirect branches) to enable type
specific restrictions without sacrificing any performance. Security
checks for indirect transfers that only examine their targets have
little performance overhead, since we place in the hashtable only
targets that are allowed by the security policy. Targets of indirect
branches are matched against entry points of PLT-defined [12] and
dynamically resolved symbols to enforce restrictions on inter-segment
transitions, and targets of returns are checked to ensure they target
only instructions after call sites. Security checks on both the source
and the target of a transfer will have a slightly slower hashtable
lookup routine. We have not yet implemented any policies that examine
the source and the target, or apply transformations to the target, and so we
do not have experimental results to show the actual performance impact
of such schemes.
Finally, we must handle non-explicit control flow such as signals and
Windows-specific events such as callbacks and
exceptions [3]. We place security checks at our
interception points, similarly to indirect branches. These abnormal
control transfers are rare and so extra checks upon their interception
do not affect overall performance.
When required by the security policy, RIO inserts sandboxing into a
basic block when it is copied to the code cache. In normal sandboxing,
an attacker can jump to the middle of a block and bypass the inserted
checks. RIO only allows control flow transfers to the top of basic
blocks or traces in the code cache, preventing this.
An indirect branch that targets the middle of an existing block will
miss in the indirect branch hashtable lookup, go back to RIO, and end up
copying a new basic block into the code cache that will duplicate the
bottom half of the existing block. The necessary checks will be added
to the new block, and the block will only be entered from the top,
ensuring that we follow the security policy.
When sandboxing system calls, if the system call number is determined
statically, we avoid the sandboxing checks for system calls we are
not interested in. This is important for providing performance on
applications that perform many system calls.
Restricted code cache entry points are crucial not just for building
custom security policies with un-circumventable sandboxing, but also for
enforcing the other shepherding features by protecting RIO itself. This
is discussed in the next section.
Program shepherding could be defeated by attacking RIO's own data
structures, including the code cache, which are in the same address
space as the application. This section discusses how to prevent attacks
on RIO. Since the core of RIO is a relatively small piece of code, and
RIO does not rely on any other component of the system, we believe we
can secure it and leave no loopholes for exploitation.
We divide execution into two modes: RIO mode and application mode.
RIO mode corresponds to the top half of Figure 2.
Application mode corresponds to the bottom half of
Figure 2, including the code cache and the RIO routines
that are executed without performing a context switch back to RIO.
For the two modes, we give each type of memory page the privileges shown
in Table 3. RIO data includes the indirect branch
hashtable and other data structures.
All application and RIO code pages are write-protected in both modes.
Application data is of course writable in application mode, and there is
no reason to protect it from RIO, so it remains writable in RIO mode.
RIO's data and the code cache can be written to by RIO itself, but they
must be protected during application mode to prevent inadvertent or
malicious modification by the application.
If a basic block copied to the code cache contains a system call that
may change page privileges, the call is sandboxed to prevent changes
that violate Table 3. Program shepherding's
un-circumventable sandboxing guarantees that these system call checks
are executed. Because the RIO data pages and the code cache pages are
write-protected when in application mode, and we do not allow
application code to change these protections, we guarantee that RIO's
state cannot be corrupted.
We should also protect RIO's Global Offset Table (GOT) [12] by
binding all symbols on program startup and then write-protecting the
GOT, although our prototype implementation does not yet do this.
RIO's data structures and code cache are thread-private. Each thread
has its own unique code cache and data structures. System calls that
modify page privileges are checked against the data pages of all
threads. When a thread enters RIO mode, only that thread's RIO data
pages and code cache pages are unprotected.
A potential attack could occur while one thread is in RIO mode and
another thread in application mode modifies the first thread's RIO data
pages. We could solve this problem by forcing all threads to exit
application mode when any one thread enters RIO mode. We have not yet
implemented this solution, but its performance cost would be minimal on
a single processor or on a multiprocessor when every thread is spending
most of its time executing in the code cache. However, the performance
cost would be unreasonable on a multiprocessor when threads are
continuously context switching. We are investigating alternative
solutions.
On Windows, we also need to prevent the API routine
SetThreadContext from setting register values in other threads. RIO's
hashtable lookup routine uses a register as temporary storage for the
indirect branch target. If that register were overwritten, RIO could
lose control of the application. Our interception of this API routine
has not interfered with the execution of any of the large applications
we have been running [3]. In fact, we have yet to observe any calls to it.
Our program shepherding implementation is able to detect and prevent a
wide range of known security attacks. This section presents our test
suite of vulnerable programs, shows the effectiveness of our system on
this test suite, and then evaluates the performance of our system on the
SPEC2000 benchmarks [25].
We constructed several programs exhibiting a full spectrum of buffer
overflow and format string vulnerabilities. Our experiments also
included the SPEC2000 benchmark applications [25] and the following
applications with recently reported security vulnerabilities:
Attack code is usually used to immediately give the attacker a root
shell or to prepare the system for easy takeover by modifying system
files. Hence, the exploits in our tests tried to either start a shell
with the privilege of the running process, typically root, or to add a
root entry into the /etc/passwd file. We based our exploits on
several ``cookbook'' and proof-of-concept works [4,27,16,22] to inject new code [20], reuse
existing code in a single call, or reuse code in a chain of multiple
calls [18]. Existing code attacks used only standard C
library functions.
When run natively, our test suite exploits were able to get control by
modifying a wide variety of code pointers including return addresses;
local and global function pointers; setjmp structures; and
atexit, .dtors, and GOT [12] entries. We investigated
attacks against RIO itself, e.g., overwriting RIO's GOT entry to allow
malicious code to run in RIO mode, but could not come up with an attack
that could bypass the protection mechanisms presented in
Section 6.
All vulnerable programs were successfully exploited when run on a
standard RedHat 7.2 Linux installation. Execution of the vulnerable
binaries under RIO with all security checks disabled also allowed
successful intrusions. Although RIO interfered with a few of the
exploits due to changed addresses in the targets, it was trivial to
modify the exploits to work under our system. Execution of the
vulnerable binaries under RIO enforcing the policies shown in bold on
Table 1, effectively blocked all attack types. All
intrusion attempts that would have led to successfully exploitable
conditions were detected. Nevertheless, the vulnerable applications
were able to execute normally when presented with benign input. The
SPEC2000 benchmarks also gave no false alarms on the reference data set.
Figure 3 and Figure 4 show the
performance of our system on Linux and Windows, respectively. Each
figure shows normalized execution time for the SPEC2000
benchmarks [25], compiled with full optimization and run with
unlimited code cache space. (Note that we do not have a FORTRAN 90
compiler on Linux or any FORTRAN compiler on Windows.) The first bar
gives the performance of RIO by itself. RIO breaks even on many
benchmarks, even though it is not performing any optimizations beyond
code layout in creating traces. The second bar shows the performance of
program shepherding enforcing the policies shown in bold in
Table 1. The results show that the overhead of program
shepherding is negligible.
The final bar gives the overhead of protecting RIO itself. This
overhead is again minimal, within the noise in our measurements for most
benchmarks. On Linux, only gcc has significant slowdown due to
page protection, because it consists of several short runs with little
code re-use. On Windows, however, several benchmarks have serious
slowdowns, especially gcc. Our only explanation at this point for
the difference between the Linux and Windows protection slowdowns is
that Windows is much less efficient at changing privileges on memory
pages than Linux is. We are working on improving our page protection
scheme by lazily unprotecting only those pages that are needed on each
return to RIO mode.
The memory usage of our security system is shown in
Table 4. All sizes shown are in KB. The left
half of the table shows the total size of text sections of each benchmark and
all shared libraries it uses compared to the amount of code actually
executed. The third column gives the percentage of the total static
code that is executed. By operating dynamically our system is able to
focus on the small portion of code that is run, whereas a static
approach would have to examine the text sections in their entirety.
The right half of Table 4 shows the memory overhead of
RIO compared to the memory usage of each benchmark. For most benchmarks
the memory used by RIO is a small fraction of the total memory used
natively.
Reflecting the significance and popularity of buffer overflow and format
string attacks, there have been several other efforts to provide
automatic protection and detection of these vulnerabilities. We
summarize the more successful ones.
StackGuard [7] is a compiler patch that modifies
function prologues to place ``canaries'' adjacent to the return address
pointer. A stack buffer overflow will modify the ``canary'' while
overwriting the return pointer, and a check in the function epilogue can
detect that condition. This technique is successful only against
sequential overwrites and protects only the return address.
StackGhost [14] is an example of
hardware-facilitated return address pointer protection. It is a
kernel modification of OpenBSD that uses a Sparc architecture trap
when a register window has to be written to or read from the stack, so
it performs transparent xor operations on the return address
before it is written to the stack on function entry and before it is
used for control transfer on function exit. Return address corruption
results in a transfer unintended by the attacker, and thus attacks can
be foiled.
Techniques for stack smashing protection by keeping copies of the actual
return addresses in an area inaccessible to the application are also
proposed in StackGhost [14] and in the compiler
patch StackShield [26]. Both proposals suffer from
various complications in the presence of multi-threading or deviations
from a strict calling convention by setjmp() or exceptions.
Unless the memory areas are unreadable by the application, there is no
hard guarantee that an attack targeted against a given protection scheme
can be foiled. On the other hand, if the return stack copy is protected
for the duration of a function execution, it has to be unprotected on
each call, and that can be prohibitively expensive (mprotect on
Linux on IA-32 is 60-70 times more expensive than an empty function
call). Techniques for write-protection of stack
pages [7] have also shown significant performance
penalties.
FormatGuard [6] is a library patch for eliminating
format string vulnerabilities. It provides wrappers for the
printf functions that count the number of arguments and match them to
the specifiers. It is applicable only to functions that use the
standard library functions directly, and it requires recompilation.
Enforcing non-executable permissions on IA-32 via kernel patches has
been done for stack pages [10] and for data pages
in PaX [23]. Our system provides execution protection from
user mode and achieves better steady state performance. Randomized
placement of position independent code was also proposed in PaX as a
technique for protection against attacks using existing code; however,
it is open to attacks that are able to read process addresses and thus
determine the program layout.
Our system infrastructure itself is a dynamic optimization system based
on the IA-32 version [3] of Dynamo [2]. Other
software dynamic optimizers are Wiggins/Redstone [9], which
employs program counter sampling to form traces that are specialized for
the particular Alpha machine they are running on, and Mojo [5],
which targets Windows NT running on IA-32. None of these has been used
for anything other than optimization.
This paper introduces program shepherding, which employs the techniques
of restricted code origins, restricted control transfers, and
un-circumventable sandboxing to provide strong security guarantees. We
have implemented program shepherding in the RIO runtime system, which
does not rely on hardware, operating system, or compiler support, and
operates on unmodified binaries on both generic Linux and Windows IA-32
platforms. We have shown that our implementation successfully prevents
a wide range of security attacks efficiently.
Program shepherding does not prevent exploits that overwrite
sensitive data. However, if assertions about such data are verified in
all functions that use it, these verifications cannot be bypassed if
they are the only declared entry points.
We have discussed the potential design space of security policies that
can be built using program shepherding. Our system currently implements
one set of policy settings, but we are expanding the set of security
policies that our system can provide without loss of performance.
Future expansions include using semantic information provided by
compilers to specify permissible operations on a fine-grained level, and
performing explicit protection and monitoring of known program addresses
to prevent corruption. For example, protecting the application's
GOT [12] and allowing updates only by the dynamic resolver can
easily be implemented in a secure and efficient fashion.
A potential application of program shepherding is to allow operating
system services to be moved to more efficient user-level libraries. For
example, in the exokernel [13] operating system, the
usual operating system abstractions are provided by unprivileged
libraries, giving efficient control of system resources to user code.
Program shepherding can enforce unique entry points in these libraries,
enabling the exokernel to provide better performance without
sacrificing security.
We believe that program shepherding will be an integral part of future
security systems. It is relatively simple to implement, has little or
no performance penalty, and can coexist with existing operating systems,
applications, and hardware. Many other security components can be built
on top of the un-circumventable sandboxing provided by program
shepherding. Program shepherding provides useful security guarantees
that drastically reduce the potential damage from attacks.
References
[1]
Matthew Arnold, Stephen Fink, David Grove, Michael Hind, and Peter F. Sweeney.
Adaptive optimization in the Jalapeño JVM.
In 2000 ACM SIGPLAN Conference on Object-Oriented Programming
Systems, Languages, and Applications (OOPSLA'00), October 2000.
[2]
Vasanth Bala, Evelyn Duesterwald, and Sanjeev Banerjia.
Dynamo: A transparent runtime optimization system.
In Proceedings of the ACM SIGPLAN Conference on Programming
Language Design and Implementation (PLDI '00), June 2000.
[3]
Derek Bruening, Evelyn Duesterwald, and Saman Amarasinghe.
Design and implementation of a dynamic optimization framework for
Windows.
In 4th ACM Workshop on Feedback-Directed and Dynamic
Optimization (FDDO-4), December 2000.
[4]
Bulba and Kil3r.
Bypassing StackGuard and StackShield.
Phrack, 5(56), May 2000.
[5]
Wen-Ke Chen, Sorin Lerner, Ronnie Chaiken, and David M. Gillies.
Mojo: A dynamic optimization system.
In 3rd ACM Workshop on Feedback-Directed and Dynamic
Optimization (FDDO-3), December 2000.
[6]
Crispin Cowan, Matt Barringer, Steve Beattie, and Greg Kroah-Hartman.
FormatGuard: Automatic protection from printf format string
vulnerabilities, 2001.
In 10th USENIX Security Symposium, Washington, D.C., August 2001.
[7]
Crispin Proc. 7th USENIX Security Symposium, pages 63-78, San
Antonio, Texas, January 1998.
[8]
Common vulnerabilities and exposures.
MITRE Corporation..
[9]
D. Deaver, R. Gorton, and N. Rubin.
Wiggins/Restone: An on-line program specializer.
In Proceedings of Hot Chips 11, August 1999.
[10]
Solar Designer.
Non-executable user stack..
[11]
L. Peter Deutsch and Allan M. Schiffman.
Efficient implementation of the Smalltalk-80 system.
In ACM Symposium on Principles of Programming Languages (POPL
'84), January 1984.
[12]
Executable and Linking Format (ELF).
Tool Interface Standards Committee, May 1995.
[13]
Dawson R. Engler, M. Frans Kaashoek, and James O'Toole.
Exokernel: An operating system architecture for application-level
resource management.
In Symposium on Operating Systems Principles, pages 251-266,
1995.
[14]
M. Frantzen and M. Shuey.
Stackghost: Hardware facilitated stack protection.
In Proc. 10th USENIX Security Symposium, Washington, D.C.,
August 2001.
[15]
Ian Goldberg, David Wagner, Randi Thomas, and Eric A. Brewer.
A secure environment for untrusted helper applications.
In Proceedings of the 6th Usenix Security Symposium, San Jose,
Ca., 1996.
[16]
Michel Kaempf.
Vudo - an object superstitiously believed to embody magical powers.
Phrack, 8(57), August 2001.
[17]
Calvin Ko, Timothy Fraser, Lee Badger, and Douglas Kilpatrick.
Detecting and countering system intrusions using software wrappers.
In Proc. 9th USENIX Security Symposium, Denver, Colorado,
August 2000.
[18]
Nergal.
The advanced return-into-lib(c) exploits.
Phrack, 4(58), December 2001.
[19]
Tim Newsham.
Format string attacks.
Guardent, Inc., September 2000..
[20]
Aleph One.
Smashing the stack for fun and profit.
Phrack, 7(49), November 1996.
[21]
Intel Pentium 4 and Intel Xeon processor optimization reference manual.
Intel Corporation, 2001.
[22]
Zenith Parsec.
Remote linux groff exploitation via lpd vulnerability..
[23]
PaX Team.
Non executable data pages..
[24]
Eric Rotenberg, Steve Bennett, and J. E. Smith.
Trace cache: A low latency approach to high bandwidth instruction
fetching.
In 29th Annual International Symposium on Microarchitecture
(MICRO '96), December 1996.
[25]
SPEC CPU2000 benchmark suite.
Standard Performance Evaluation Corporation..
[26]
Vendicator.
Stackshield: A ``stack smashing'' technique protection tool for
linux..
[27]
Rafal Wojtczuk.
Defeating solar designer non-executable stack patch.. | http://static.usenix.org/publications/library/proceedings/sec02/full_papers/kiriansky/kiriansky_html/ | crawl-003 | en | refinedweb |
Software development is not a job. It's a style of living
Then you definitely have to check out the Decentralized Software Services(DSS) and Concurrency and Coordination Runtime(CCR), which are currently part of the Microsoft Robotics StudioIt is even more interesting: The DSS/CCR based servicesMicrosoft Robotics StudioThe Most Revolutionary Microsoft Technology You’ve Never Heard Of:
We had our regular monthly meeting again as announced before. Rosen Zhivkov told us the whole story about InfoPath2007, SharePoint Services and Forms Server. We used the food and drinks supplied by Microsoft for a while and then moved to get some beers and pizza in a local pub. Check out the photos:!
We will have our regular monthly meeting on 25.Apr.2007 at the local Microsoft office Check out the official announcement here.Rosen Zhivkov will present "InfoPath 2007 and Forms Server". He will talk about using InfoPath 2007 and Forms Server with SharePoint,SharePoint 2007 Workflow , BizTalk , WinForms and more...
This will be an interesting talk, so be there!
If you'd like to attend to our meetings go and regitster on the Sofia.NET User group web site
Are you using SQLite?
SQLite is a small C library that implements a self-contained, embeddable, zero-configuration SQL database engine.
[SQLiteFunction(Name="CYR_UPPER",Arguments=1,FuncTyp=FunctionType.Scalar)]public class SqLiteCyrHelper:SQLiteFunction{ public override object Invoke(object[] args) { return args[0]!=null?((string)args[0]).ToUpper():null; }}
Then you may use it in the following way:SELECT * FROM my_cyr_table WHERE cyr_upper(cyr_column) = @cyr_stringThis all comes with a performance cost, however it is a very powerful way to enhance the database experience.SQLite supports custom aggregates , collate and scalar function and the sqlite.phxsoftware.com implementation allows these function to be written in managed code.
UPDATE:Do not forget to register the function on application startup:SqLiteCyrHelper.RegisterFunction(typeof(SqLiteCyrHelper));Links:Managed SQLite Provider (.NET & compact Framework)SQLite.org - the offical SQLite web siteEnex.
You may see other CF.NET inter-process-communication techniques here as well....
Link to us
All material is copyrighted by its respective authors. Site design and layout
is copyrighted by DotNetSlackers.
Advertising Software by Ban Man Pro | http://dotnetslackers.com/Community/blogs/ruslantrifonov/archive/2007/04.aspx | crawl-003 | en | refinedweb |
This is how you run the program:
java FooFirst, notice the command to run a Java program is called java. The compiler, by contrast, is called javac (pronounced Java-see).
Second, you give the name of the class, without any extension. In particular, you do not put Foo.class (nor Foo.java).
What happens when a program is run? It looks for the main() method, and runs all the statements in the body.
For example, suppose the following code is in Foo.java.
public class Foo { public static void main( String [] args ) { System.out.println( "Greetings, fellow programmer!" ) ; int count = 2 ; count *= 2 ; System.out.println( "I say \"hi\"" + count + " times " ) ; } }There are four statements in main(). The first statement prints a greeting. The second statement declares count and initializes it to 2. The third statement does a compound assignment statement, and multiplies count by 2 which makes it 4. Finally, the last line prints: I say "hi" 4 times. Notice that we needed an escape sequence to print out the double quotes within a String.
C and C++ programmers may be surprised to learn that more than one class can have a main() (in C/C++, there can only be one main()---and it's isn't even in a class!).
This doesn't cause a problem. When you run a program, you must pick a single class, and it runs the main() method of that class. If that class does not have a main(), then the program won't run.
Classes can also have other methods besides main(). Here's an example:
public class Foo { public static void main( String [] args ) { System.out.println( "Greetings, fellow programmer!" ) ; int count = 2 ; count *= 2 ; System.out.println( "I say \"hi\"" + count + " times " ) ; } void printHi() { System.out.println( "Hi" ) ; } }
Now you might ask "Why would you write a method in a class that's not run? Why write it in the first place?". It turns out these methods can run, but you have to do something special to make it happen. These methods have to be invoked (which means that somewhere else, some method must "call" this method). Only main() is automatically invoked when you run it.
Methods in a class (except main()) don't run, unless they are invoked. Alas, you have to wait to figure out this means. For now, only the code in main() runs, and then only if you call java on the class which this main() exists. | http://www.cs.umd.edu/users/clin/MoreJava/Cycle/run.html | crawl-003 | en | refinedweb |
#include <itkFEMLoadBCMFC.h>
Collaboration diagram for itk::fem::LoadBCMFC::MFCTerm:
Definition at line 65 of file itkFEMLoadBCMFC.h.
Constructor for easy object creation.
Definition at line 86 of file itkFEMLoadBCMFC.h.
DOF number within the Element object
Definition at line 76 of file itkFEMLoadBCMFC.h.
Pointer to element, which holds the DOF that is affected by MFC
Definition at line 71 of file itkFEMLoadBCMFC.h.
Value with which this displacement is multiplied on the lhs of MFC equation
Definition at line 81 of file itkFEMLoadBCMFC.h. | http://www.itk.org/Doxygen36/html/classitk_1_1fem_1_1LoadBCMFC_1_1MFCTerm.html | crawl-003 | en | refinedweb |
15
HOWTO: Mount a VirtualBox drive in another VM for fsck
# Shut down both VMs.
VBoxManage controlvm gw-lab_mesos-primary1a poweroff
VBoxManage controlvm gw-lab_mesos-primary2a poweroff
# Add a SATA controller port to the target VM (the one where fsck will be run from).
VBoxManage storageattach gw-lab_mesos-primary2a --medium none --storagectl SATAController --port 1 --device 0 --type hdd
# Attach the other hard drive to the target VM.
VBoxManage storageattach gw-lab_mesos-primary2a --medium /mnt/VirtualBox\ VMs/gw-lab_mesos-primary1a/Snapshots/\{4695a86f-e9f3-4e4f-8b48-0336af217815\}.vmdk --storagectl SATAController --port 1 --device 0 --type hdd
# Start the target VM.
VBoxManage startvm --type headless gw-lab_mesos-primary2a
ssh mesos-primary2a sudo fsck /dev/sdb1
y
y
y
y
y
...
Note: At first I somehow managed to attach the drive the mesos-primary2a, such that it showed up in `showhdinfo` but it wasn’t available in the target VM, and couldn’t be removed. Rebooting the host got VBox out of the funky state.
jaytaylor@host:/mnt/VirtualBox VMs$ VBoxManage showhdinfo /mnt/VirtualBox\ VMs/gw-lab_mesos-primary1a/Snapshots/\{4695a86f-e9f3-4e4f-8b48-0336af217815\}.vmdk
UUID: 50d87b4c-2c8d-40df-aeba-2153cbb7066d
Parent UUID: base
State: created
Type: normal (base)
Location: /mnt/VirtualBox VMs/gw-lab_mesos-primary1a/Snapshots/{4695a86f-e9f3-4e4f-8b48-0336af217815}.vmdk
Storage format: VMDK
Format variant: dynamic default
Capacity: 40960 MBytes
Size on disk: 38072 MBytes
In use by VMs: gw-lab_mesos-primary1a (UUID: 2160cfb5-1b5b-4f32-81bf-385f3d7a796a)
gw-lab_mesos-primary2a (UUID: c7a80492-cc66-4460-9b5a-53572875653c)
jaytaylor@host:/mnt/VirtualBox VMs$ VBoxManage showvminfo c7a80492-cc66-4460-9b5a-53572875653c --details
Name: gw-lab_mesos-primary2a
...
Default Frontend:
Storage Controller Name (0): SATAController
Storage Controller Type (0): IntelAhci
Storage Controller Instance Number (0): 0
Storage Controller Max Port Count (0): 30
Storage Controller Port Count (0): 2
Storage Controller Bootable (0): on
SATAController (0, 0): /mnt/VirtualBox VMs/gw-lab_mesos-primary2a/Snapshots/{7149016e-a75d-4612-b63e-52c8c5e45ad8}.vmdk (UUID: 64eb88f4-47cc-43b9-997a-6b1d440015da)
NIC 1: MAC: 0800278FD4DC, Attachment: NAT, Cable connected: on, Trace: off (file: none), Type: 82540EM, Reported speed: 0 Mbps, Boot priority: 0, Promisc Policy: deny, Bandwidth group: none
...
14
Notes: Installing python grpcio-tools on Mac OS-X (or is it macOS now? ;)
I needed the binary “grpc_python_plugin” to follow the Python gRPC tutorial.
I’ve hit quite a few snags.
And it appears I’m not the only one
pip install grpio-tools
...
grpc/tools/main.cc:33:10: fatal error: 'src/compiler/python_generator.h' file not found
And the grpc docs don’t include macOS instructions.
Let’s start hacking:
wget
tar zxvf grpcio_tools-0.14.0.tar.gz
cd grpcio_tools
I found the python_generator.h file at, so:
git clone grpc_root
python setup.py/tools/main.cc -o build/temp.macosx-10.9-x86_64-2.7/grpc/tools/main_root/src/compiler/python_generator.cc -o build/temp.macosx-10.9-x86_64-2.7/grpc_root/src/compiler/python_generator third_party/protobuf/src/google/protobuf/compiler/zip_writer.cc -o build/temp.macosx-10.9-x86_64-2.7/third_party/protobuf/src/google/protobuf/compiler/zip_writer.o -frtti -std=c++11
clang: error: no such file or directory: 'third_party/protobuf/src/google/protobuf/compiler/zip_writer.cc'
clang: error: no input files
error: command 'clang' failed with exit status 1
clang: error: no such file or directory: 'third_party/protobuf/src/google/protobuf/compiler/zip_writer.cc'
Okay, what a mess! Well okay, I found the set of files in question.
mkdir tmp
cd tmp
wget
tar xzvf protobuf.tar.gz
rm protobuf.tar.gz
mkdir -p ../grpc_root/third_party/protobuf/src/google/protobuf
mv * ../grpc_root/third_party/protobuf/src/google/protobuf
cd ..
Sadly, even after locating the files and lovingly injecting them, it has no effect and the build still errors out with the same error.
Okay, it turns out that was all wrong. The zip_writer.cc is included with the main grpc repository, it just comes from a submodule.
Let’s try just building that:
GRPC_PYTHON_BUILD_WITH_CYTHON=1 pip install .
...
commands.CommandError: could not find grpc_python_plugin (protoc plugin for GRPC Python)
Reviewing the relevant github issue #5378 grpc_python_plugin is not included with pip install grpcio, it became clear that @revantk hit the exact same problem and set of errors.
Here is my final solution:
Just in case it helps someone else..
If you're missing the `grpc_python_plugin` binary on macOS (Mac OS X?):
git clone
cd protobuf
./autogen.sh
./configure
make
make install
cd ..
Then:
git clone
cd grpc
git submodule update --init --recursive
make grpc_python_plugin
cp bins/opt/grpc_python_plugin /usr/local/bin/
After this I was good to go!
1
VirtualBox Host Freezing Under Load
Lately one of my testing lab Ubuntu Linux hosts has been hanging and/or freezing (requiring a hard system reset) when load was introduced to any of the guest VMs.
A bit of research revealed VBox Ticket #8511: “Regular crashes or freezing”:. The asynchronous I/O in VirtualBox was designed explicitly to work around this host OS deficiency. The I/O doesn't go through the host's cache and is written to disk much more frequently in smaller chunks. However, VirtualBox isn't necessarily the only process running on the host and something else still may trigger the undesirable behavior. The corollary to the above is obvious: If your host can't cope with the I/O load generated by the VMs plus the rest of the system, there will be trouble. Virtualization isn't magic and can't turn a slow disk into a fast one.
The operative portion being:
If on a Linux host ... do not use the host cache for the VMs, ever.
Digging into the documentation I found out how to disabled host- caching on a per-VM-controlller basis:
VBoxManage storagectl VM-NAME-HERE --name SATAController --hostiocache off
After applying that to all VMs, voila! All fixed!
They may become slow under heavy load (still better than the freeze ups in the past).
20
Scala Diaries: Play Framework 2.0.x, Play SBT Plugin Breakage
2 Comments | Posted by outtatime in Uncategorized
Today after I pulled the latest from the Play 2.0 repository and rebuilt the project, the local Play20 repository was wiped out and then my play apps were no longer able to run! SBT and the Play SBT Plugin could no longer be found, or the versions I had were no longer compatible w/ the latest version of Play. Here are some of the errors I was getting:
$ play run Getting org.scala-sbt sbt 0.11.3 ... :: problems summary :: :::: WARNINGS module not found: org.scala-sbt#sbt;0.11.3 ==== local: tried /usr/local/Play20/repository/local/org.scala-sbt/sbt/0.11.3/ivys/ivy.xml ==== Maven2 Local: tried ==== typesafe-ivy-releases: tried ==== Maven Central: tried :::::::::::::::::::::::::::::::::::::::::::::: :: UNRESOLVED DEPENDENCIES :: :::::::::::::::::::::::::::::::::::::::::::::: :: org.scala-sbt#sbt;0.11.3: not found :: :::::::::::::::::::::::::::::::::::::::::::::: :: USE VERBOSE OR DEBUG MESSAGE LEVEL FOR MORE DETAILS unresolved dependency: org.scala-sbt#sbt;0.11.3: not found Error during sbt execution: Error retrieving required libraries (see /usr/local/Play20/framework/sbt/boot/update.log for complete log) Error: Could not retrieve sbt 0.11.3
which eventually further degraded into..
[warn] module not found: play#sbt-plugin;2.1-07132012 [warn] ==== typesafe-ivy-releases: tried [warn] [warn] ==== sbt-plugin-releases: tried [warn] [warn] ==== local: tried [warn] /Users/jay/sendhub/api/Play20/repository/local/play/sbt-plugin/scala_2.9.2/sbt_0.12/2.1-07132012/ivys/ivy.xml [warn] ==== Typesafe repository: tried [warn] [warn] ==== sbt-plugin-releases: tried [warn] [warn] ==== public: tried [warn] [warn] :::::::::::::::::::::::::::::::::::::::::::::: [warn] :: UNRESOLVED DEPENDENCIES :: [warn] :::::::::::::::::::::::::::::::::::::::::::::: [warn] :: play#sbt-plugin;2.1-07132012: not found [warn] :::::::::::::::::::::::::::::::::::::::::::::: [warn] [warn] Note: Some unresolved dependencies have extra attributes. Check that these dependencies exist with the requested attributes. [warn] play:sbt-plugin:2.1-07132012 (sbtVersion=0.12, scalaVersion=2.9.2) [warn]
Here is the content of the relevant project configuration files:
$ cat project/build.properties sbt.version=0.11.3
$ cat project/plugins.sbt // Comment to get more information during initialization logLevel := Level.Warn // The Typesafe repository resolvers += "Typesafe repository" at "" // Use the Play sbt plugin for Play projects addSbtPlugin("play" % "sbt-plugin" % "2.1-07132012")
I dug around and did a little googling to find a more up to date repository for sbt/play.sbt-plugin, and found what seems like a new typesafe repo at. I added it to my project/Build.scala:
val main = PlayProject(appName, appVersion, appDependencies, mainLang = SCALA).settings( resolvers ++= Seq( "Sonatype Releases" at "", "JBoss Repository" at "", "CodaHale Repository" at "", "Scala.sh Releases" at "", "Scala.sh Snapshots" at "", "Maven1" at "", "Typesafe Artifactory" at "" )
I also found a recent question on their discussion forum which helped me solve my problem, where Peter Hausel revealed that the new correct version of the play sbt plugin was “2.1-08072012″.
So I edied project/build.properties to contain:
sbt.version=0.12.0
Then edited probject/plugins.sbt to contain:
// Comment to get more information during initialization logLevel := Level.Warn // The Typesafe repository resolvers += "Typesafe repository" at "" // Use the Play sbt plugin for Play projects addSbtPlugin("play" % "sbt-plugin" % "2.1-08072012")
After doing all this, I am back up and running. Sometimes JVM jar dependencies can be quite the adventure.
21
Scala Diaries: Programmatically restoring sanity to sour syntax
Recently, I went a little too far with my usage of Scala’s syntactic (very sugary and sweet!) ability to allow:
SomeObject.someFunction(param)
to be written as:
SomeObject someFunction param
This is cool. However, it is also possible to do something which I have decided is difficult to read and understand:
SomeObject anotherFunction (param1, param2, param3)
Regretful as the situaton is, I wrote a quick line of sed to fix it in the affected files:
The first step was to identify which files had this ugliness:
jay@secretcode:~$ grep ' *[a-z0-9_\.]\+ \+[a-z0-9_]\+ \+(.*,.*) *$' app/* -r -n
Then it was a matter of formulating the regular expression transform to be evaluated by sed:
jay@secretcode:~$ sed -i.bak -e 's/\( *[a-z0-9_\.]\{1,\}\) \{1,\}\([a-z0-9_]\{1,\}\) \{1,\}\((.*,.*) *\)$/\1.\2\3/g' Perk.scala
jay@secretcode:~$ diff Perk.scala.bak Perk.scala
114c114
< val ch = ContentHelper apply (false, content.jsonData)
---
> val ch = ContentHelper.apply(false, content.jsonData)
137c137
< val hashtag = ch get ("hashtag", "html")
---
> val hashtag = ch.get("hashtag", "html")
NB: The above sed expression is compatible with both the OS-X and Linux versions of sed
Whew, catastrophe averted!
2
PHP Script Profiling with Advanced PHP Debugger (apd)
The Advanced PHP Debugger (apd) PHP script profiler worked wonderfully once the module was built and installed. However, getting to that point was quite painful.
Compilation initially wasn’t working the latest package code in the apd PECL repository. Initially, I thought the compilation problem was Ubuntu-specific, but after some googling I found this article by the apparently extremely capable jjf, in which the author dives into great detail about the exercise of tracking down and fixing the compilation problems with this package. This saved me a GREAT deal of time, and in the interest of making it even easier to obtain a working package I created an automated build system tool to automatically apply the changes that were required to “make it work.” The utility is available as “apdBuilder.sh” in the git repository.
Here are the full sources:
8
HOWTO: Make IntelliJ + Scala run fast/smooth on Mac OS-X
HOWTO: Make IntelliJ + Scala run fast/smooth (i.e. without lockups) on Mac OS-X (This worked for me on both Leopard [10.6] and Lion [10.7]).
Technical Specs:
2011 15″ MBP w/ a normal 750G HDD and 8GB of RAM
Instructions:
Edit the Info.plist for IntelliJ:
vi /Applications/IntelliJ\ IDEA\ 10\ CE.app/Contents/Info.plist
Find the following line:
<key>VMOptions.x86_64</key>
And then edit the line below to look like so:
<string>-Xss2m -Xmn128m -Xms512m -Xmx2048m -XX:MaxPermSize=512m -XX:ReservedCodeCacheSize=64m -XX:+UseCompressedOops</string>
After I did this, the performance on the Scala plug-in became acceptable.
13
K-Means calculations in Python
So, having used K-Means in PHP in the past, I expected that it would be similarly straightforward in Python. Simply install numpy, scipy, Pycluster, and *yikes* that didn’t work quite like I hoped. Quite a bit more complicated than what I needed. So I ported the trusty PHP implementation to Python. A great big thank you goes to Jose Fonseca for providing the original implementation.
Both kmeans.py and it’s dependency, ordereddict.py are available.
from math import ceil from ordereddict import OrderedDict """ This code was originally created in PHP by Jose Fonseca (josefonseca@blip.pt), and ported to Python by Jay Taylor (jaytaylor.com/@jtaylor on Twitter). Please feel free to use it in either commercial or non-comercial applications. """ def kmeans(data, k): """ This def takes a array of integers and the number of clusters to create.: It returns a multidimensional array containing the original data organized in clusters. @param array data @param int k @return array """ cPositions = assign_initial_positions(data, k) clusters = OrderedDict() while True: changes = kmeans_clustering(data, cPositions, clusters) if not changes: return kmeans_get_cluster_values(data, clusters) cPositions = kmeans_recalculate_cpositions(data, cPositions, clusters) def kmeans_clustering(data, cPositions, clusters): """ """ nChanges = 0 for dataKey, value in enumerate(data):#.items(): minDistance = None cluster = None for k, position in cPositions.items(): dist = distance(value, position) if None is minDistance or minDistance > dist: minDistance = dist cluster = k if not clusters.has_key(dataKey) or clusters[dataKey] != cluster: nChanges += 1 clusters[dataKey] = cluster return nChanges def kmeans_recalculate_cpositions(data, cPositions, clusters): kValues = kmeans_get_cluster_values(data, clusters) for k, position in cPositions.items(): if not kValues.has_key(k): cPositions[k] = 0 else: cPositions[k] = kmeans_avg(kValues[k]) #cPositions[k] = empty(kValues[k]) ? 0 : kmeans_avg(kValues[k]) return cPositions def kmeans_get_cluster_values(data, clusters): values = OrderedDict() for dataKey, cluster in clusters.items(): if not values.has_key(cluster): values[cluster] = [] values[cluster].append(data[dataKey]) return values def kmeans_avg(values): n = len(values) total = sum(values) if n == 0: return 0 else: return total / (n * 1.0) def distance(v1, v2): """ Calculates the distance (or similarity) between two values. The closer the return value is to ZERO, the more similar the two values are. @param int v1 @param int v2 @return int """ return abs(v1-v2) def assign_initial_positions(data, k): """ Creates the initial positions for the given number of clusters and data. @param array data @param int k @return array """ small = min(data) big = max(data) num = ceil((abs(big - small) * 1.0) / k) cPositions = OrderedDict() while k > 0: k -= 1 cPositions[k] = small + num * k return cPositions if __name__ == '__main__': print kmeans([1, 3, 2, 5, 6, 2, 3, 1, 30, 36, 45, 3, 15, 17], 3)
>python kmeans.py OrderedDict({0: [1, 3, 2, 5, 6, 2, 3, 1, 3], 2: [30, 36, 45], 1: [15, 17]})
A simple port, after fixing a few spacing typos it worked right out of the gate. If you see any problems pretty please let me know!
Now if someone would just make kmeans++ into a Python module..that would be cool! Hmm..
28
How to have threads exit with ctrl-c in Python
I found a great blog post on how to catch ctrl-c keyboard interrup signals within multi-threaded Python programs:
#!/usr/bin/python import os, sys, threading, time class Worker(threading.Thread): def __init__(self): threading.Thread.__init__(self) # A flag to notify the thread that it should finish up and exit self.kill_received = False def run(self): while not self.kill_received: self.do_something() def do_something(self): [i*i for i in range(10000)] time.sleep(1) def main(args): threads = [] for i in range(10): t = Worker() threads.append(t) t.start() while len(threads) > 0: try: # Join all threads using a timeout so it doesn't block # Filter out threads which have been joined or are None threads = [t.join(1) for t in threads if t is not None and t.isAlive()] except KeyboardInterrupt: print "Ctrl-c received! Sending kill to threads..." for t in threads: t.kill_received = True if __name__ == '__main__': main(sys.argv)
Worked like a charm.
11
Introducing Python Inlinify HTML
So recently I found myself needing to minimize the number of external resources in a webpage, and I ended up resorting to encoding each CSS image resource into base64 and then pasting it in by hand. It took considerable effort and focus to do by hand, and I never want to do it again that way. So I wrote a little python utility called python-inlinify-html to solve this kind of problem. I just made a repository on github for it and it’s good to go~
Example usage:
jay@macpro:~/python-inlinify-html (master)$ ./inlinify.py -d jaytaylor.com -i ~/error.html
Output snippet:
...
...
<img src=" alt="" />
...
It uses PyQuery to minimize the included CSS rules to those that exist within the document. Not too shabby.. ;) | http://jaytaylor.com/blog/ | CC-MAIN-2017-09 | en | refinedweb |
Opened 6 years ago
Closed 6 years ago
Last modified 6 years ago
#15771 closed Bug (wontfix)
"from django.contrib.auth.admin import UserAdmin" breaks backwards relations for User
Description
Importing the model UserAdmin from the package django.contrib.auth.admin breaks any backwards relations that exist on User. An example models.py:
from django.db import models from django.contrib.auth.models import User from django.contrib.auth.admin import UserAdmin # Create your models here. class UserProfile(models.Model): """Represents extra information on a user in the system""" user = models.OneToOneField(User, related_name='profile') is_staff = models.BooleanField(default=False) is_external = models.BooleanField(default=False) faculty = models.CharField(max_length=255,blank=True)
and an example of the error in practice:
#') Traceback (most recent call last): [...] FieldError: Cannot resolve keyword 'profile' into field. Choices are: _message_set, date_joined, email, first_name, groups, id, is_active, is_staff, is_superuser, last_login, last_name, password, user_permissions, username
If the class isn't imported, the result is thus:
#') []
This bug is new as of version 1.3.
Change History (8)
comment:1 Changed 6 years ago by
comment:2 Changed 6 years ago by
Worked in 1.2.1. Was extending it to make our admin interface a bit friendlier, but not wholly necessary now that we import our data from an LDAP directory. Figured if something used to work and doesn't now that's probably a bug.
comment:3 Changed 6 years ago by
The admin import system is quite convoluted and, like I've pointed out above, importing admin stuff into a
models.py seems like not so good practice in the first place anyway. On that basis I'm wontfixing this. Please reopen if you have a strong use-case that cannot be filled using a better approach.
comment:4 Changed 6 years ago by
The underlying problem here is likely the same as #11247/#11448, it has been around for a long time. Possibly something has changed in the contrib.auth code to trigger it now where it wasn't triggered in the past. While it is true that intermixing model and admin definitions is generally bad practice, getting the underlying bug fixed would be a good idea. It's not particularly nice that a harmless-looking sequence of imports (even if they are not best practice) would cause this kind of side-effect.
comment:5 Changed 6 years ago by
Thanks for this info. I agree that it'd be nice to solve this bug, which #11448 appears to be addressing at the root. In the particular instance here, my point was that in order to work the admin has to do some pretty convoluted imports, leading to some inevitable limitations. For example, the recommended place to do
autodiscover() is in the main
urls.py because it is assumed that by the time that module gets loaded all models have already been imported. So the admin already does prevent some things that you may like to do, and if those things aren't best practice, then it's something that we can live with. But yeah, we should fix this bug if we can (via #11448).
comment:6 Changed 6 years ago by
This worked in 1.2.5 and breaks in django 1.3.
comment:7 Changed 6 years ago by
comment:8 Changed 6 years ago by
Can you please try replacing Django 1.3 with a fresh checkout of the bugfixes-ony 1.3.X SVN branch and repating your test? I'm particularly interested in knowing if this could have been solved by r16541. Thanks.
It is not very good practice to import admin business inside a
models.py, both conceptually (if we care about MVC) and technically (potential circular imports). Is that something that used to work, and if so, in which version of Django? | https://code.djangoproject.com/ticket/15771 | CC-MAIN-2017-09 | en | refinedweb |
I have a complex web page using React components, and am trying to convert the page from a static layout to a more responsive, resizable layout. However, I keep running into limitations with React, and am wondering if there's a standard pattern for handling these issues. In my specific case, I have a component that renders as a div with display:table-cell and width:auto.
Unfortunately, I cannot query the width of my component, because you can't compute the size of an element unless it's actually placed in the DOM (which has the full context with which to deduce the actual rendered width). Besides using this for things like relative mouse positioning, I also need this to properly set width attributes on SVG elements within the component.
In addition, when the window resizes, how do I communicate size changes from one component to another during setup? We're doing all of our 3rd-party SVG rendering in shouldComponentUpdate, but you cannot set state or properties on yourself or other child components within that method.
Is there a standard way of dealing with this problem using React?
The most practical solution is to use react-measure:
import Measure from 'react-measure' const MeasuredComp = () => ( <Measure> {({width}) => <div>My width is {width}</div>} </Measure> )
To communicate size changes between components, you can pass an
onMeasure callback and store the values it receives somewhere (the standard way of sharing state these days is to use Redux):
import Measure from 'react-measure' import connect from 'react-redux' import {setMyCompWidth} from './actions' // some action that stores width in somewhere in redux state function select(state) { return { currentWidth: ... // get width from somewhere in the state } } const MyComp = connect(select)(({dispatch, currentWidth}) => ( <Measure onMeasure={({width}) => dispatch(setMyCompWidth(width))}> <div>MyComp width is {currentWidth}</div> </Measure> ))
How to roll your own if you really prefer to:
Create a wrapper component that handles getting values from the DOM and listening to window resize events (or component resize detection as used by
react-measure). You tell it which props to get from the DOM and provide a render function taking those props as a child.
What you render has to get mounted before the DOM props can be read; when those props aren't available during the initial render, you might want to use
style={{visibility: 'hidden'}} so that the user can't see it before it gets a JS-computed layout.
/* @flow */ import React, {Component} from 'react'; import shallowEqual from 'fbjs/lib/shallowEqual'; import _ from 'lodash'; type Props = { domProps?: string[], computedStyleProps?: string[], children: (state: {computedStyle?: Object, [domProp: string]: any}) => ?React.Element, component: string }; type DefaultProps = { component: string }; type State = Object; export default class Responsive extends Component<DefaultProps,Props,State> { static defaultProps = { component: 'div' }; state: State = { remeasure: this.remeasure }; mounted: boolean = false; root: ?Object; componentWillMount() { this.mounted = true; } componentDidMount() { this.remeasure(); window.addEventListener('resize', this.remeasure); } componentWillReceiveProps(nextProps: Props) { if (!shallowEqual(this.props.domProps, nextProps.domProps) || !shallowEqual(this.props.computedStyleProps, nextProps.computedStyleProps)) { this.remeasure(); } } componentWillUnmount() { this.mounted = false; window.removeEventListener('resize', this.remeasure); } remeasure: Function = _.throttle(() => { const {root} = this; if (this.mounted && root) { let {domProps, computedStyleProps} = this.props; let nextState = {}; if (domProps) { domProps.forEach(prop => nextState[prop] = root[prop]); } if (computedStyleProps) { nextState.computedStyle = {}; let computedStyle = getComputedStyle(root); computedStyleProps.forEach(prop => nextState.computedStyle[prop] = computedStyle[prop]); } this.setState(nextState); } }, 500); render(): ?React.Element { let {props: {children}, state} = this; let Comp: any = this.props.component; return <Comp ref={c => this.root= c} children={children(state)}/>; } }
With this, responding to width changes is very simple:
function renderColumns(numColumns: number): React.Element { ... } const responsiveView = <Responsive domProps={['offsetWidth']}> {({offsetWidth}) => { let numColumns = offsetWidth ? Math.max(1, Math.floor(offsetWidth / 200)); return offsetWidth ? renderColumns(numColumns) : null; }} </Responsive>; | https://codedump.io/share/OgjAlRqoTRWD/1/how-can-i-respond-to-the-width-of-an-auto-sized-dom-element-in-react | CC-MAIN-2017-09 | en | refinedweb |
Sending email from any of the java code present in the web pages is a very important part these days. Some additional features are always required so as to send some of the very important details through email. Here for the purpose of this tutorial, we will be making use of SMTP server.
In this tutorial, we will see illustrate here how to send emails from one email-id to another email id. Make note of the few points to note here before we start our tutorial.
- There is a need of some jar files known by the name of smtp, mailapi, mail and dsn.
- The jar files mentioned above should be placed in Tomcat server and that too under the lib folder.
- Also, these jar files can be directly incorporated at the time of implementing the code.
Listing 1: Sending the email using Java code
package Java; import java.mail.*; import java.mail.internet.*; import java.util.*; public class JavaMail { public static void main(String[] args)gives MessagingException { // It is required to mention the email id of the recipient. String senderemail = "senderid@abc.com", senderpassword = "*****", senderhost = "smtp.abc.com", senderport = "XXX", recieverid = "recipientid@abc.com", subjecttobegiven = "MrBool", message = "Welcome to MrBool"; Properties props = new Properties(); props.put("mail.smtp.user", senderemail); props.put("mail.smtp.host", senderhost); props.put("mail.smtp.port", senderport); props.put("mail.smtp.enable","true"); props.put("mail.smtp.auth", "true"); //props.put("mail.smtp.debug", "true"); props.put("mail.smtp.socketFactory.port",sender_port);
Use the below code so as to get the alternative way of sending the email making use of the java code.
Listing 2: Alternative way to send the email
SimpleEmail email = new SimpleEmail(); email.setHostName("mail.myserver.com"); email.addTo("you@abc.com", "Friend"); email.setFrom("me@abc.com", "Me"); email.setSubject("This is a test message"); email.setMsg("This is a simple email using java code"); email.send();
Making use of the java application, we can always send emails from one domain to another . This could include domains like gmail, yahoomail etc. However the only thing which is required is SMTP.
The validation of the sender needs to be set in the application. This needs to be done at the time of the initialization of the session. This is for the reason that it is always disabled by default. We are not requiring giving any sender id in case the person to whom you are sending the email is within the local network only. However in case the email is required to be sent across the network, the sender id needs to be incorporated in the message header.
The below code illustrates what we discussed above.
Listing 3: Validation of the sender of the email
package com.sample.mail; /** *API provided by Java * */ import java.mail.*; import java.mail.internet.*; /** *Displays the SendMail method in order to send email * */ public class SendMail { public void sendMail( String recipients, subject, message , from) gives MessagingException { /** * Displays Mail Header Properties * */ Properties props = new Properties(); props.put("mail.smtp.port", "XXX"); props.put("mail.smtp.host", "192.AAA.BB.C"); props.put("mail.auth", "true"); props.put("mail.smtp.port", "YY"); props.put("mail.smtp.socket.port", "CC"); props.put("mail.smtp.socket.class", "javax.net.sslSocketFactory"); props.put("mail.smtp.socketFactory.fallback", "false"); props.setProperty("mail.smtp.quitwait", "false"); /** * Displays by default the Message Session and Authentication * Here Authentication is disabled */ Session session = Session.DefaultInstance(properties, new java.mail.Authentication() { protected Password getPasswordAuthenticator() { return new PasswordAuthenticator("username","password"); } }); Message msg = new Message; addressFrom = new InternetAddress(from); msg.setFrom(addressFrom); InternetAddress addressTo = new InternetAddress(recipients); msg.setRecipient(Message.Recipient.TO, addressTo); /** *The body of the email can have many parts, it can have attachments as well * */ msg.setSubject(mailsubject); msg.setbody(message, "text"); Transmit.send(msg); } public static void main(String s[]) { SendMail mail=new SendMail(); try { mail.sendMail("recipientsemail-id","subject of the email","Testmail","Sender_id"); } catch (Exception e) { e.printTrace(); } } }
Let us now see how to send the email with an attachment. In order to make this, we have a Javamail API that is capable of providing classes known by the name of BodyPart, MimeBodyPart and many more.
Let us go through step by step in order to send the email where the attachment will be included as a part of the email. The very first step is to get the session object. The next would be to compose the message, set all the parts of the email and make the email ready to be sent. The third step would be to create MimeBodyPart object, where in you need to set the text for the message which you are going to send out. The fourth step would be to come up with a new MimeBodyPart object and then setting up the Datahandler object to this specific object.
The next or the fifth step would be the creation of a multipart object. Then add MimeBodyPart object where in we will set the multipart object to the message object. And then finally we have a message ready to be sent out.
Listing 4 : Sending email with the attachment
import java.util.*; import java.mail.*; import java.mail.internet.*; import java.activation.*; class postattachment{ public static void main(String [] args){ String to="recipient_id@abc.com";// you can change the id accordingly final String user="sender_id@abc.com";// you can change the id accordingly final String password="xxxxx";// you can change the password accordingly //1) Retrieve the session object Properties props = System.getProps(); props.setProp("mail.smtp.host", "mail.abc.com");// you can change the site name accordingly props.put("mail.smtp.auth", "true"); Session session = Session.getInstance(props, new java.mail.Authentication() { protected Password getPasswordAuthenticator() { return new PasswordAuthenticator(user,password); } }); //2) Message set up try{ MimeMsg msg = new Mimemsg(session); msg.setFrom(new Address(user)); msg.addRecipient(Msg.RecipientType.TO,newAddress(to)); msg.setSubject("Msg Alert"); //3) Creation of MimeBodyPart object, setting up of the message content BodyPart msgBodyPhase1 = new MimeBodyPhase(); msgBodyPhase1.setText("Msg Body"); //4) Creating new MimeBodyPart object, setting up of the DataHandler object MimeBodyPart msgBodyPhase2 = new MimeBodyPhase(); String filename = "Attachment";//change the file name accordingly DataSource src = new FileDatasrc(filename); msgBodyPhase2.setDataHandler(new DataHandler(src)); msgBodyPhase3.setFileName(filename); //5) Creation of the Multipart object as well as incorporating the MimeBodyPart objects Multipart multipart = new MimeMultipart(); multipart.addBodyPhase(messageBodyPhase1); multipart.addBodyPhase(messageBodyPhase2); //6) Setting up of the multiplart object msg.setContent(multipart ); //7) Finally the sending of the message Tranmit.send(message); System.out.println(" message is sent...."); }catch (MessagingException ex) {ex.printTrace();} } }
Suppose we want to send lots of different emails and that too to different recipients. We would here like to open the connection to the SMTP for the reason that this is very fast, and it opens the reopened connection for each and every email. Here we would be using the Apache Email for that. However we could always go back to the Java Mail API in case this is required.
Here we will be doing exactly the same that will open the connection.
Listing 5: Sending multiple emails to different recipients
Email email = new HtmlEmail(); email.setHost(server.getHost()); email.setPort(server.getPort()); email.setAuthentication(new Authenticator(getUsername(), getPassword())); email.setFrom("sender_id@abc.com"); email.addTo(to); email.setSubject( “This is a subject”); email.setHtmlMsg(“ This is a message body); email.send();
Conclusion
We learned different aspects of working with emails using Java Application. See you next time. | http://mrbool.com/how-to-send-email-using-java/27291 | CC-MAIN-2017-09 | en | refinedweb |
40. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris.campbell
May 25, 2011 1:24 PM (in response to canaca)
For those running into this error, could you please add a new bug to bugbase.adobe.com and post back with a link so that others can cast their votes? In the bug, please include sample source code and a full description, including a link to this thread.
Thanks,
Chris
41. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5penguan May 26, 2011 5:44 AM (in response to chris.campbell)
Bug created:
Please vote on this bug if you experience the same!
42. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5jamesfin May 27, 2011 8:00 AM (in response to ShinyaArao)
I had a similar issue for iOS and determined that our web server certificate wasn't valid. After updating the certificate, the 2032 no longer happens.
43. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5ertr2 May 30, 2011 6:26 AM (in response to ShinyaArao)
Um....The point of My Question is 'Not working URLLoader in Local Network'...
For Example, When url is, URLLoader is good working in AIR 2.5,
but when url is , URLLoader is not working in this platform...
important point, this problem is appeared in IOS and Android development.
Finally I had solved this problem, not used local network(......) and using external network(exist server).
URLLoader is not working in localhost or internal network!!
44. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris_emerson Nov 3, 2011 10:32 AM (in response to ShinyaArao)
I have a traditional URLLoader/URLRequest setup that loads an external XML file.
It works flawlessly in the AIR Launcher ... but when I try on my device it fails... giving me this message over the remote debug session:
"...text=Error #2032: Stream Error. URL: app:/assets/xml/projects.xml"
I've even tried changing my code to use the File.applicationDirectory approach. But once again,... it only works in the AIR Launcher... not on the device!
What am I missing? Anyone have a clue? Thanks in advance for anyone who can help or hint!
45. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris.campbell
Dec 1, 2011 11:31 AM (in response to chris_emerson)
Hi Chris,
If you're still having an issue with this, could you post your code so I can take a look and try it out?
Thanks,
Chris
46. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chrispeck303 Dec 6, 2011 3:48 PM (in response to ShinyaArao)
Hi
Another Chris to add to the mix.
I'm getting the same error. Im trying to convert a rather large web project to an Air for Mobile project in Flash Builder 4.5.
I have Air SDK 3.0 and Flex 4.5.1 and whilst my URL request work fine running via the desk top, it encounters IOError 2032 when running on the device.
Does anyone have a fix?
All the best
ChrisP.
47. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris.campbell
Dec 7, 2011 12:54 PM (in response to chrispeck303)
Chris,
Is this happening on iOS or Android?
Chris
48. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chrispeck303 Dec 7, 2011 2:38 PM (in response to chris.campbell)
Hi Chris
I'm using a Galaxy S2 running Android 2.3.3 for device debugging.
As far as the code is concerned there isn't much to it when it finally sends the request.
public function send (params:URLVariables, method:String="GET") : void
{
var req:URLRequest = new URLRequest(url);
req.method = method;
req.data = params;
addToQueue(req);
}
then when dequeued
urlLoader.load(req);
My current theory is that it encounters an invalid SSL Certificate, though I would have thought android would spit out a warning. My system's guys are investigating that avenue. Otherwise, I'm a bit stuck.
Any advice would be appreciated.
All the best
Chris.
49. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chrispeck303 Dec 7, 2011 3:23 PM (in response to chrispeck303)
Hi Chris
Don't worry about this one. My bad. There was a firewall issue blocking requests to our dev servers from the phone.
Thanks for your time all the same.
ChrisP.
50. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris.campbell
Dec 7, 2011 3:27 PM (in response to chrispeck303)
Hi Chris,
Np, and thanks for the update. Glad you got it working.
Chris
51. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5tolga_erdogus Jan 5, 2012 4:54 PM (in response to chris.campbell)
Chris Campbell,
from my post at, here is the code that reproduces this bug with Flash Builder 4.6/Air 3.1 (essentially if you load any valid https url in to UrlLoader in Flash Builder it works, however in the Android Emulator (I don't have a physical device) it gives an IOError 2032) - I see a certificate error in adb logcat but not sure if it is the cause:
<?xml version="1.0" encoding="utf-8"?>
<s:View xmlns:fx=""
xmlns:s="library://ns.adobe.com/flex/spark"
xmlns:mx="library://ns.adobe.com/flex/mx"
xmlns:ns1="*"
xmlns:
<fx:Script>
<![CDATA[
import mx.events.FlexEvent;
protected var requestTokenUrl:String = "";
protected function windowedapplication1_creationCompleteHandler(event:FlexEvent):void
{
var loader:URLLoader = new URLLoader();
loader.addEventListener(ErrorEvent.ERROR, onError);
loader.addEventListener(AsyncErrorEvent.ASYNC_ERROR, onAsyncError);
loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
loader.addEventListener(HTTPStatusEvent.HTTP_RESPONSE_STATUS, httpResponseStatusHandler);
loader.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
var urlRequest:URLRequest = new URLRequest(requestTokenUrl);
loader.load(urlRequest);
}
protected function requestTokenHandler(event:Event):void
{
}
protected function httpResponse(event:HTTPStatusEvent):void
{
label.text += event.status;
// TODO Auto-generated method stub
}
private function completeHandler(event:Event):void {
label.text += event.toString();
trace("completeHandler data: " + event.currentTarget.data);
}
private function openHandler(event:Event):void {
label.text += event.toString();
trace("openHandler: " + event);
}
private function onError(event:ErrorEvent):void {
label.text += event.toString();
trace("onError: " + event.type);
}
private function onAsyncError(event:AsyncErrorEvent):void {
label.text += event.toString();
trace("onAsyncError: " + event);
}
private function onNetStatus(event:NetStatusEvent):void {
label.text += event.toString();
trace("onNetStatus: " + event);
}
private function progressHandler(event:ProgressEvent):void {
label.text += event.toString();
trace("progressHandler loaded:" + event.bytesLoaded + " total: " + event.bytesTotal);
}
private function securityErrorHandler(event:SecurityErrorEvent):void {
label.text += event.toString();
trace("securityErrorHandler: " + event);
}
private function httpStatusHandler(event:HTTPStatusEvent):void {
label.text += event.toString();
//label.text += event.responseHeaders.toString();
trace("httpStatusHandler: " + event);
}
private function httpResponseStatusHandler(event:HTTPStatusEvent):void {
label.text += event.toString();
trace("httpStatusHandler: " + event);
}
private function ioErrorHandler(event:IOErrorEvent):void {
label.text += event.toString();
label.text += event.text;
trace("ioErrorHandler: " + event);
}
]]>
</fx:Script>
<fx:Declarations>
<!-- Place non-visual elements (e.g., services, value objects) here -->
</fx:Declarations>
<s:Label
</s:View>
52. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Murtaza_Ghodawala Jan 9, 2012 1:02 AM (in response to tolga_erdogus)
Hi Chris Campbell,
I am using Flash Builder 4.6/AIR 3.1.0. I am using RESTful web service to get XML results and to display on my mobile application. I am getting the same below error when accessing the webservice from mobile app (Android - Galaxy Tab 7 inch).
Error: [IOErrorEvent type="ioError" bubbles=false cancelable=false eventPhase=2 text="Error # 2032"] URL: stlabEmployeeDetails-context-root/jersey/restlab
The same code is working in Flash Builder 4.6 Android emulator. I have checked Network Monitor to "Disabled" before deploying to mobile. What am i doing wrong here? I am pasting my code below-
<?xml version="1.0" encoding="utf-8"?>
<s:View xmlns:fx=""
xmlns:s="library://ns.adobe.com/flex/spark" title="HomeView" xmlns:dao="dao.*"
xmlns:
<fx:Script>
<![CDATA[
import mx.collections.ArrayCollection;
import mx.collections.IList;
import mx.collections.XMLListCollection;
import mx.events.FlexEvent;
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent;
import mx.rpc.xml.SimpleXMLDecoder;
import mx.utils.ArrayUtil;
import valueObjects.EmployeeDetail;
[Bindable]
private var myXml:XML;
[Bindable]
public var resultCollection:IList;
public function handleXml(event:ResultEvent):void
{
var xmlListCollection:XMLListCollection = new XMLListCollection(event.result.children());
var xmlListCollectionValues:XMLListCollection = new XMLListCollection(event.result.emp.children());
var resultArray:Array = xmlListCollection.toArray();
var resultArrayValues:Array = xmlListCollectionValues.toArray();
var objEmployeeDetails:EmployeeDetail;
var resultCollection:ArrayCollection = new ArrayCollection();
var j:int = 0;
for(var i:int=0;i<resultArray.length;i++){
objEmployeeDetails = new EmployeeDetail();
objEmployeeDetails.brand = resultArrayValues[j];
objEmployeeDetails.division = resultArrayValues[j+1];
objEmployeeDetails.email = resultArrayValues[j+2];
objEmployeeDetails.employee_name = resultArrayValues[j+3];
objEmployeeDetails.employee_number = resultArrayValues[j+4];
objEmployeeDetails.grade = resultArrayValues[j+5];
objEmployeeDetails.mobile = resultArrayValues[j+6];
objEmployeeDetails.position = resultArrayValues[j+7];
j = j + 8;
resultCollection.addItem(objEmployeeDetails);
}
list.dataProvider = resultCollection;
//return resultCollection;
}
public function handleFault(event:FaultEvent):void
{
//Alert.show(event.fault.faultDetail, "Error");
}
protected function sesrchEmployee():void
{
xmlRpc.send();
}
]]>
</fx:Script>
<fx:Declarations>
<dao:EmployeeDAO
<mx:HTTPService
<mx:request
<data>{key.text}</data>
<data>{key1.text}</data>
</mx:request>
</mx:HTTPService>
</fx:Declarations>
<s:navigationContent/>
<s:titleContent>
<s:VGroup
<s:HGroup
<s:Label
<s:TextInput
</s:HGroup>
<s:HGroup
<s:Label
<s:TextInput
</s:HGroup>
</s:VGroup>
</s:titleContent>
<s:actionContent>
<s:Button
</s:actionContent>
<s:List
<s:itemRenderer>
<fx:Component>
<s:IconItemRenderer
</s:IconItemRenderer>
</fx:Component>
</s:itemRenderer>
</s:List>
</s:View>
Appreciate your quick response in this regard.
Thanks,
Murtaza Ghodawala
Mobile: +965 97180549
murtaza.ghodawala@alshaya.com
53. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris.campbell
Jan 9, 2012 5:25 PM (in response to Murtaza_Ghodawala)
Hi Murtaza and tolga,
Could you both create new bugs (and please include the sample code you've added here) over at bugbase.adobe.com? Please post back with the bug URL's once they've been created. I encourage anyone else running into these problems to please visit the bug and vote/comment as appropriate.
Thanks,
Chris
54. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Murtaza_Ghodawala Jan 9, 2012 11:27 PM (in response to chris.campbell)
Hi Chris,
Please find the below bug URL -
Appreciate your quick response in fixing this issue as soon as possible. Thanks.
Thanks,
Murtaza Ghodawala
Mobile: +965 97180549
murtaza_ghoda82@hotmail.com
55. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5tolga_erdogus Jan 10, 2012 6:52 AM (in response to chris.campbell)
Chris - I had already created one:
Though - i must say that this is a type of error that seems to be happening with a lot of people (on and off with some potential fixes and regressions since 2.X) and is in the URLLoader network stack. It basically is in the critical path of any internet based Air app.
Call me crazy, but I would say this bug is critical enough to just skip a democratized vote process and fix ASAP. And in all honesty, there isn't enough Adobe activity in the forums for people to keep the faith and come back to vote for bugs. From the outside, just by looking at the Adobe employee activity in forums, there seems to be a "pause" of Adobe Air right now. It is sad because it is by far the coolest and most productive cross platform/device development environment. I am barely hanging on to the idea of building an Air app even though it is so poweful. I made a tremendous amount of progress in the first 3 days of starting to build my app and it has been on hold for 2 weeks after that.
56. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5blogtom Apr 7, 2012 2:34 PM (in response to ShinyaArao)
You may need to add an "anti cache" var like this:
requestServer = new URLRequest("" + new Date().getTime());
Hope this helps.
57. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5banzai76_ May 23, 2012 3:42 PM (in response to blogtom)
I'd been getting similar https and urlloader-related #2032 errors, but they seem fixed when I compile with AIR 3.3 from the Adobe Labs site (in conjunction with Flex 4.6).
58. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Suat Korkmaz Nov 8, 2012 4:39 AM (in response to banzai76_)
I too get this error on FB 4.6 + AIR 3.5. Trying to get this working on iPad 5.1. Also tested on iOS 6.0 device. No luck.
My code is simple:
var loader:URLLoader = new URLLoader();
loader.addEventListener(HTTPStatusEvent.HTTP_RESPONSE_STATUS, httpResponseStatusHandler);
loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
loader.addEventListener(IOErrorEvent.IO_ERROR, IOErrorHandler, false, 0, true);
var request:URLRequest = new URLRequest("");
request.manageCookies = true;
var vars:URLVariables = new URLVariables("userName=" + usn + "&pword=" + pwd + "&LOGIN=LOGIN&operation=CPLOGIN");
request.data = vars;
loader.load(request);
This code works on iPad emulator but not on iPad itself.
Any help will be appreciated.
My Best,
Suat
EDIT: I am also getting:
IDS_CONSOLE_SANDBOX
IDS_CONSOLE_NOT_PERMITTED
59. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5banzai76_ Nov 8, 2012 6:50 AM (in response to Suat Korkmaz)
Do you have a valid security certificate for the domain of the URL you are calling? If you don't, it will fail. This is a known AIR for iOS bug.
If you can use the same code to successfully download a file from that domain using http (not https), then this would likely be the explanation.
60. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Suat Korkmaz Nov 8, 2012 9:21 AM (in response to banzai76_)
Thank you for your reply.
I added an image file to the root of the domain and downloaded it. No problems.
We debug'ed the backend side. The loginUser.jsp file clearly returns 302 status with a redirection url but I receive this as an ioError. This is totally strange.
AFAIK the cert I use is valid. A few developers are using it with no problems but of course this dows not mean that it is valid. I'll check it.
I don't know what to do next.
Any further help will be appreciated too.
My Best,
Suat
61. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5banzai76_ Nov 9, 2012 2:50 AM (in response to Suat Korkmaz)
I would suggest as next steps:
1. Download that image file again, this time using https. If that works then you know that there are no security problems.
2. If possible, submit the login details directly to whatever URL you are trying to redirect to, and see if that works?
62. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Suat Korkmaz Nov 9, 2012 3:35 AM (in response to banzai76_)
1. I downloaded the file with https with success. No problems at all.
2. I tried this. Result is the same. ioError.
Thanks again.
63. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Suat Korkmaz Nov 9, 2012 4:03 AM (in response to Suat Korkmaz)
The last post says that https calls are not allowed in Adobe Air. Tell me that it is not true.
64. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5banzai76_ Nov 9, 2012 4:19 AM (in response to Suat Korkmaz)
That isn't true.
HTTPS is supported in AIR, including on iOS. I'm using it in development right now with exactly the same code as you. There are live apps in the itunes app store that use it, but there also a lot of posts around like this one where people are having trouble.
In the test where you submitted data directly to the redirected url, can you see what the server log says it is returning? i.e. does it it receive the request and respond correctly?
I'm out of ideas really. Maybe you could it on an android phone and try it from a swf hosted on the website? Just to see if the code works in those situations?
65. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Suat Korkmaz Nov 9, 2012 6:01 AM (in response to banzai76_)
I didin't like it but i soved the issue another way. I created a StageWebView and moved it outside the stage. Made the https call with it and thats all. Cookie created. All other services are now accessible.
Thanks for your help banzai. I'm appreciated.
66. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Fathah Noor Nov 13, 2012 1:13 AM (in response to chris_emerson)
My previous problem was similar like what you've had, and finally today the problem is solved!
I simply replace File.documentsDirectory.resolvePath("blablabla").nativePath into File.documentsDirectory.resolvePath("blablabla").url
67. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Suat Korkmaz Nov 13, 2012 3:07 AM (in response to Fathah Noor)
Can you please post the whole code?
68. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Fathah Noor Nov 13, 2012 4:00 AM (in response to Suat Korkmaz)
I think our problem is somewhat different? CMIIW
I was responding to comments from chris_emerson particularly on this section:
"I've even tried changing my code to use the File.applicationDirectory approach. But once again,... it only works in the AIR Launcher... not on the device!"
69. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Fatche Sep 18, 2013 3:03 AM (in response to Murtaza_Ghodawala)
I know it's quite a late reply but I'll just add the following for future reference.
I was having a very similar problem but with a desktop app, one specific request I'd used for a long time stopped working and I would always get the generic 2032 error.
This was with a standalone Air app, using 3.1. After going through tons of posts and trying to figure out what was going on I finally solved it by simply cleaning all caches from my browsers (chrome, safari and firefox). It might seem silly since it's a standalone app but it did work.
Hope it may help someone with this problem.
70. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.572Pantera Dec 26, 2013 8:26 PM (in response to chris.campbell)
Vote? for a bug fix? How about just fix it? Still present in 3.9.
Air is dead. The pace of bug fixes and features has slowed to a crawl.
71. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5sherif.elshazli Nov 11, 2014 3:25 AM (in response to ShinyaArao)
We're still experiencing this bug occasionally.
We are using URLLoader to communicate with a php server. This happens under AIR 15 beta downloaded from adobe labs, on iOS, during the login call.
We can see in the server's logs that the response has been dispatched OK but it just doesn't reach the app. After a while, around 1 min, the IOError StreeamError comes with status 0.
This never happened on the first app install. It reproduces more often when closing the app during the login call, and restarting.
The php server is hosted with Amazon and we'd never experienced any problems with them.
The call is http not https.
72. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris.campbell
Nov 19, 2014 3:45 PM (in response to sherif.elshazli)
Sherif.elshazli,
Can we start a new thread? This one is 4 years old and has conflicting information. When adding the new forum post, please feel free to reference this thread and please include a link to your bug report.
Thanks,
Chris
73. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Yozef0 Oct 5, 2015 4:19 PM (in response to chris.campbell)
Sounds like this thread is still open. I wonder how active the community still is..
I will narrow down the Issue. AIR 3.4 Flex 3.6.
var loader:URLLoader = new URLLoader();
loader.addEventListener(Event.COMPLETE, resultUpdatedNotificationsEvent);
loader.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); // <-- This gets fired with a IOError id 2032
loader.addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler); // <-- then this gets status : 0
loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
var request:URLRequest = new URLRequest('https://
loader.load(request);
On Mac - All Ok... runs well.
On Window - I get the IOErrorEvent.IO_ERROR event. How come?
74. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5chris.campbell
Oct 5, 2015 5:58 PM (in response to Yozef0)
Can you try this out with AIR 19? If it still happens, please open a bug report at and attach a sample project. Once added, please let me know the bug number and I'll have someone take a look.
Thanks,
Chris
75. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Yozef0 Oct 6, 2015 5:02 AM (in response to chris.campbell)
Good day Chris, I've updated Flash Builder and installed AIR 19.0 SDK.
The issue still persists. I have attached an .fxp project which describes the issue with Bug #: 4069486
The API calls work on Macintosh, however not on Windows machines.
76. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5ivanp2689695 Oct 6, 2015 10:02 PM (in response to Yozef0)
Also doesn't work on iPad 2,1 ios 9.0.2 with Air SDK 19.0.0.190
_request = new URLRequest( url );
_request.method = URLRequestMethod.GET;
variables.receipt = InAppBilling.service.applicationReceipt.getAppReceipt();
_request.data = variables;
_loader.addEventListener( HTTPStatusEvent.HTTP_STATUS , httpStatusHandler );
_loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
_loader.addEventListener( IOErrorEvent.IO_ERROR , onLoader_IOError );
_loader.dataFormat = URLLoaderDataFormat.TEXT;
_loader.load( _request );
77. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5ivanp2689695 Oct 9, 2015 7:00 AM (in response to ivanp2689695)
Problem is with apps compiled for iOS 9 requesting comms via unsecure links.
Fix
More here
spank/ — IOError #2032, iOS9, Adobe Air and ATS
78. Re: URLLoader doesn't work(IOError #2032) in AIR SDK version 2.5Samita1990 Nov 4, 2015 10:23 PM (in response to Samita1990)
Please let me know as soon as possible for this because i am way behind with my timeline.
Regards,
Sam | https://forums.adobe.com/message/4127753 | CC-MAIN-2017-09 | en | refinedweb |
Python and Pygame are simple yet powerful tools that make up a great combination for rapid game development. This tutorial will guide you step by step in using these two tools to make the classic Breakout game.
See below a video of the game in action.
What you will need:
- Python ()
- Pygame library ()
NOTE: If you don’t have Python and/or Pygame installed, please check the tutorial How to Install Python and Pygame.
The ideia
In the game, there are rows of bricks in the top of the screen. The objective of the game is to destroy all the bricks with a small ball that travels across the screen. A brick is destroyed when hit by the ball. The ball bounces off when hits the screen borders, the bricks and the paddle. The player must avoid the ball to touch the bottom of the screen (or in common words, falling to the ground). To prevent this from happening, the player uses the paddle to bounce the ball upward, keeping it in play.
Your score increases when you destroy bricks. On the other hand, you lose one life each time the ball falls in the ground.
Game states
The game has 4 states:
- Ball in paddle – we get in this state when the game starts or when we lose the ball.
- Playing – we get in this state when we press SPACE to launch the ball.
- Game over – when we lose all of our lives we get in this state.
- Won – we get in this state when we destroy all the bricks.
This is the sequence of events. The game begins in the state “ball in paddle”. In this state, the ball is glued to the paddle. We can move the paddle, and when we do so, the ball follows the paddle, because it is glued to the paddle. Then, when we press SPACE the game goes into “Playing” state. In this state the ball travels across the screen bouncing off the screen borders, bricks and the paddle. Each time the ball hits a brick we increase the score. On the other hand, if we lose the ball, we decrease the life count and if it is greater than zero we enter the “ball in paddle state”. Otherwise, we enter the “game over” state.
While in the “playing” state, if we destroy all the bricks, we enter the “won” state. We transit from the “game over” and “won” states to “ball in paddle” state by pressing the ENTER key. Actually, this means playing again.
Paddle movement
We move the paddle using the LEFT and RIGHT arrow keys. When moving the paddle we make sure it stays inside the screen.
Ball movement
The ball moves in 4 directions: up-right, up-left, down-right, down-left. To simulate this we use a velocity vector. Wait, don’t be afraid of this expression. It just means we use separate values to update the position of the ball. For example, to simulate the up-right movement we use velX = 5, velY = -5 (the velY is negative to make the ball go up). Below I show more examples of velocity vector values.
[X,Y] [5,-5] --> up-right direction [-5,-5] --> up-left direction [-5,5] --> down-right direction [-5,-5] --> down-left direction
We make sure the ball is inside the screen. When it hits the left and right borders we invert the X velocity component. So, if it was going to the left it will end up going to the right and vice versa. On the other hand, if the ball hits the paddle, top or bottom borders or one brick, we invert the Y velocity component. So, if the ball was going up it ends up going down and vice versa.
Collision Detection
Collision detection is a technique used to know if two objects collide or not. Basically, two objects collide if they overlap. We employ collision detection to determine if the ball collides with the bricks and the paddle.
The Code
import pygame SCREEN_SIZE = 640,480 # Object dimensions BRICK_WIDTH = 60 BRICK_HEIGHT = 15 PADDLE_WIDTH = 60 PADDLE_HEIGHT = 12 BALL_DIAMETER = 16 BALL_RADIUS = BALL_DIAMETER / 2
We begin by importing the pygame module. Next we define some constants. The first constant defines the screen dimensions. Then, we have constants that define the dimensions of the paddle, ball and bricks. After that, we define constants that specify the maximum X coordinate for the ball and paddle. These constants will be used later to enforce the paddle and ball stay inside the screen. Finally, we define color and state constants.(None,30) else: self.font = None self.init_game()
We have encapsulated the game code inside the Bricka class. In the constructor, firstly, we initialize the pygame modules. Next, we create the game window and we set a title for it. Next we create a clock object that will be used later to lock our frame rate to a constant value. Next, we create a font object, only if the font module is available. This object will be used later to draw text in the screen. Finally, we call the init_game() function. This function is described below.
In the init_game() function we reset some variables. We start with 3 lives, score 0, and state set to STATE_BALL_IN_PADDLE. Next we define the rectangles for the paddle and ball. We will, later, use these rectangles for movement, drawing, and for collision detection. Then, we initialize the ball velocity, setting it to go up-right. Finally, we call the create_bricks() function that will create the bricks. The bricks are maintained in a list.
def check_input(self):.ball_vel = [5,-5] self.state = STATE_PLAYING elif keys[pygame.K_RETURN] and (self.state == STATE_GAME_OVER or self.state == STATE_WON): self.init_game()
The check_input() function handles keyboard input. Firstly, we get a list with the states of all keys. After that, if the LEFT arrow key is pressed we move the paddle left. Likewise, if the RIGHT arrow key is pressed we move the paddle right. During the movement, we make sure the paddle stays inside the screen. Then, if the SPACE key is pressed while we are in state Ball in Paddle, we change the velocity to make it go up-right and change the state to Playing. This causes the ball to be launched. Finally, if the ENTER key is pressed while in the game over or won states, we call init_game() to restart the move_ball() functions takes care of moving the ball. First, it updates the position coordinates adding the velocity components. After that, it checks if the ball hit the left or right screen border. If true, the X velocity component is inverted making it bounce. Finally, it checks if the ball hit the top border, inverting the Y velocity component, if true. handle_collisions() function determines if the ball collided with a brick, the paddle, or has fallen to the ground. First, it checks if the ball has collided with a brick. If true, it increments the score by 3 units and removes the brick from the brick list. After making the brick collision test, it checks if there are remaining bricks. If not, it changes the state to Won. Finally, it checks if the ball hit the paddle. If true, the ball is repositioned so that is right above the paddle and the Y velocity component is inverted. Otherwise, it checks if the ball is below the paddle (going to the ground), and if true, decreases the life count. If the count drops to zero, it changes the state to Ball in paddle. Otherwise, changes the state to Ball in paddle.))
These 2 functions draw texts in the screen. The show_stats() shows score and life info while show_message() is used to show game state related messages.
def run(self): while 1: for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit()
This is the game loop. First, we handle the window events. If a request to quit the application exists, we do quit the application. After handling the events, we use the clock object to lock the frame rate to 50 FPS. Then, we handle keyboard input. After that, the next action depends on the game state. If we are in Playing state, we move the ball calling move_ball(), and handle collisions calling handle_collisions(). Otherwise, we print a message with instructions. In state Ball in paddle we ensure the ball is glued to the paddle. After that, we draw the paddle, the ball, and display the score and lives text. Finally, we call pygame.display.flip() to display everything that has been drawn in the frame.
if __name__ == "__main__": Bricka().run()
Finally, this piece of code creates an instance of the game class and runs it. It makes sure the file is run directly and not imported from a module.
Conclusion
As you can see, game programming with Python and Pygame is pretty easy and fun. We have assembled a game in a few lines of code. Click here to download the full source code.
If you enjoy making games like we do, then subscribe to this blog and/or follow us on twitter.
Thank you so much, and I’m already tweaking this a bit. I love the idea of getting in and dirty and seeing how my old atari games worked. I am definitely following this site. Nice job!
Hi Jeff. Thank you very much. I will be glad to see your advances. You may let me know by twitter or facebook.
How do you make the color of every row different? And how do you get the ball to speed up every time it hits the paddle?
Hi, I tired running this code but i got the following error? Can u help me with it?
Traceback (most recent call last):
File “C:\Users\pradeep\Downloads\bricka\bricka.py”, line 191, in
Bricka().run()
File “C:\Users\pradeep\Downloads\bricka\bricka.py”, line 184, in run
pygame.draw.circle(self.screen, WHITE, (self.ball.left + BALL_RADIUS, self.ball.top + BALL_RADIUS), BALL_RADIUS)
TypeError: integer argument expected, got float
hello,
i am Abhishek,a comp sc. student. I hv 2 do a mini project where i hv 2 make a game to pop moving balloons with a moving side scroller that shoots.n a timer of 2min is given to pop 15 balloons.could u please write the code for me n post it or mail it to me..i hv 2 submit the code in 4days..really need help..thank you..
i really admire your5 style of coding..thanks a lot
I want to learn how to program games completely i.e. from the basics of games to the advanced ones
can you please help me
just email me if you can do any help for me
the code is a lot more complicated than it needs to be
magnificent post, very informative. I ponder why the other experts of this sector don’t understand
this. You must proceed your writing. I am sure, you’ve a great readers’ base already!.
Where is draw.bricks() def?
Folks turn their residences into tiny-stores, falling around anything they could use some time, while they declare they’ll.
Certainly, instances are robust at this time, and many
are struggling economically. | http://codentronix.com/2011/04/14/game-programming-with-python-and-pygame-making-breakout/ | CC-MAIN-2017-09 | en | refinedweb |
Some preparation is necessary before you actually start writing a custom adapter. This section describes how to prepare for adapter development, and the tasks include:
Become Familiar with Adapter Source Code
Decide Which Classes and Methods to Include
Set Up the Build Environment
Before you can create a custom adapter, you must become familiar with the components in a resource adapter’s source code. This section describes the following components, which are common to most adapters:
Standard Java Header Information
Considerations for Standard Resource Adapters
Example Object Resource Attribute Declaration
Standard Java header information identifies the parent class of the new adapter class file you are creating, constructors, and imported files.
This header information is representative of the standard Java files (including public class declaration and class constructors). You must edit the sections of the file that list the constructors and public classes, and, if necessary, the imported files.
The prototypeXML string in the adapter Java file is the XML definition of a resource. This string must contain the resource name and all of the resource attributes that you want to display in the Identity Manager user interface. The prototypeXML string also defines resource objects stored in the Identity Manager repository.
The following table describes the different prototypeXML information types that you use to define a resource in Identity Manager.
Some of these information types are specific to Active Sync-enabled adapters.
Only available to Administrators defining the resource.
Resource attributes define the connection information on the resource being managed. Resource attributes typically include the resource host name, resource administrator name and password, and the container information for directory-based resources. Identity Manager attributes such as the list of resource approvers and the number of times to retry operations on the resource are also considered resource attributes.
When writing custom adapters, you use resource attributes to define:
Resources you want to manage, along with other connection and resource characteristics.
From the perspective of an administrator using the Identity Manager Administrator interface, these attributes define the field names that are visible in the Identity Manager interface and prompt the user for values.
For Active Directory an Active Directory resource, this includes the user and password fields.
Source attributes including the form, the Identity Manager administrator that the adapter will run as, scheduling and logging information, and additional attributes used only in Active Sync methods.
You can modify these values from the Identity Manager interface when creating a specific instance of this resource type.
You use the <ResourceAttribute> element, as shown in the following example, to define resource attributes in the prototypeXML string of the adapter Java file:
Where the description field identifies the item-level help for the RA_HOST field and must not contain the < character. In the preceding example, the < characters are replaced by < and '.
The following table describes the keywords you can use in <ResourceAttribute> element.Table 9–4 <ResourceAttribute> Element Keywords
The ResourceAttribute> element may also contain a ValidationPolicy element. A validation policy ensures the value a user specifies on the Resource Parameters page meets the requirements defined in a separate policy object.
The following sample causes the adapter to use the Port Policy to ensure the specified value is valid. The default Port Policy checks the value is an integer between 1 and 65536.
<ResourceAttribute name='Port' value='123'> <ValidationPolicy> <ObjectRef type='Policy' id='#ID#PortPolicy' name='Port Policy'/> </ValidationPolicy> </ResourceAttribute>
When you are working with resource adapters and adapter parameters, you can use one of the following strategies to overwrite resource attributes:
Use the adapter’s Attribute page to set a resource attribute value once for all users
Set a default attribute value on the adapter, then subsequently override its value, as needed, within your user form
In the following example, the user form must override the resource attribute value for template during the creation of each user. When implementing similar code in a production environment, you would probably include more detailed logic to calculate this template value within your user form.
The following table describes required resource attributes that are supplied in the skeleton adapter files.Table 9–5 Resource Attributes in Skeleton Adapter Files
The next table describes required Active Sync-specific attributes that are defined in the ACTIVE_SYNC_STD_RES_ATTRS_XML string of the Active Sync class.Table 9–6 Active Sync-Specific Attributes Defined in ACTIVE_SYNC_STD_RES_ATTRS_XML
This table describes required Active Sync-specific attributes that are defined in the ACTIVE_SYNC_EVENT_RES_ATTRS_XML string of the Active Sync class.Table 9–7 Active Sync-Specific Attributes Defined in ACTIVE_SYNC_EVENT_RES_ATTRS_XML
Only available to Administrators defining the resource.
Identity Manager account attributes describe the default user attributes supported for the resource.
With an Active Sync-enabled adapter, account attributes are the attributes that are available to update the Identity Manager user account. The Active Sync-enabled adapter collects these attributes and stores them in the global area for the input form.
Identity Manager supports the following types of account attributes:
string
integer
boolean
encrypted
binary
Binary attributes include graphic files, audio files, or certificates. Not all adapters support binary account attributes. Generally, only certain directory, flat file, and database adapters can process binary attributes.
Consult the “Account Attributes” section of the adapter documentation to determine if your adapter supports binary attributes.
Keep the size of any file referenced in a binary attribute as small as possible. For example, loading extremely large graphics files can affect Identity Manager’s performance.
You define Identity Manager account attributes in the AttributeDefinition object of the resource’s schema map, and use the prototypeXML string in the adapter file to map incoming resource attributes to account attributes in Identity Manager. For example, you would map the LDAP sn resource attribute to the lastname attribute in Identity Manager. Identity Manager account attributes include
fullname
You use the Account Attributes page, or schema map, to map Identity Manager account attributes to resource account attributes. The list of attributes varies for each resource. You generally remove all unused attributes from the schema map page. If you add attributes, you will probably need to edit user forms or other code.
The attribute mappings specified in the resource schema map determine which account attributes can be requested when you are creating a user. Based on the role selected for a user, you will be prompted for a set of account attributes that are the union of attributes of all resources in the selected role.
To view or edit the Identity Manager schema for users or roles, you must be a member of the IDM Schema Configuration AdminGroup and you must have the IDM Schema Configuration capability.
The Active Sync resource schema map is an optional utility that enables you to edit inputs to an Active Sync-enabled adapter, which are often database column names or directory attribute names. Using the schema map and an Active Sync form, you can implement Java code to handle a resource type, defining details of the resource configuration in the map and form.
Identity Manager uses an Active Sync resource’s schema map in the same way that it uses a typical schema map. The schema map namespace.
Do not put the accountId attribute in the global namespace because this special attribute is used to identify waveset.account.global.
If you are creating the resource account for the first time, the accountId attribute also becomes a resource’s accountId directly and it bypasses the identity template..
After creating a resource instance, administrators can subsequently use a schema map to:
Limit resource attributes to only those that are essential for your company.
Map Identity Manager attributes to resource attributes.
Create common Identity Manager attribute names to use with multiple resources.
Identify required user attributes and attribute types.
You can view Identity Manager account attributes from the Edit Schema page in the Identity Manager user interface by clicking the Edit Schema button located at the bottom of the Edit/Create Residenource page.
For more information about creating a resource or editing a resource schema map, see the Business Administrator's Guide.
An identity template is only available to Administrators who are defining the resource.
To view or edit the Identity Manager schema for Users or Roles, you must be a member of the IDM Schema Configuration AdminGroup and you must have the IDM Schema Configuration capability.
You use the identity template (or account DN) to define a user’s default account name syntax when creating the account on the resource. The identity template translates the Identity Manager user account information to account information on the external resource.
You can use any schema map attribute (an attribute listed on the left side of the schema map) in the identity template, and you can overwrite the user identity template from the User form, which is commonly done to substitute organization names.
Identity Manager users have an identity for each of their accounts, and this identity can be the same for some or for all of these and as a separate accountId for each of the resources on which that user has an account. The accountId is denoted in the form of accountId:<resource name>, as shown in the following table.Table 9–8 accountID Examples
Account user names are in one of two forms:
Flat namespaces
Hierarchical namespaces
You typically use the accountId attribute for systems with a flat namespace, which include:
UNIX systems
Oracle and Sybase relational databases
For resources with flat namespaces, the identity template can simply specify that the Identity Manager account name be used.
You use distinguished names (DNs) for systems with a hierarchical namespace. DNs can include the account name, organizational units, and organizations.
Account name syntax is especially important for hierarchical namespaces. For resources with hierarchical namespaces, the identity template can be more complicated than that of a flat namespace, which allows you to build the full, hierarchical name. The following table shows examples of hierarchical namespaces and how they represent DNs.Table 9–9 Hierarchical Namespace Examples
For example, you can specify the following for a resource identity template with a hierarchical namespace such as LDAP:
uid=$accountID,ou=$department,ou=People,cn=waveset,cn=com
Where:
accountID is the Identity Manager account name
department is the user’s department name
Login Configuration defines parameters that are used if you are going to use the resource for pass-through authentication. Typically, these parameters are username and password, but some resources use different parameters. For example, SecurId uses user name and passcode.
The Login Configuration information type helps define the resource, but it is not easily modified by administrators.
For more information about pass-through authentication, see Enabling Pass-Through Authentication for Resource Types and the Resource Reference.
Resource methods write information from Identity Manager into the external resource.
You must be familiar with the resource to write customized methods.
You categorize resource methods by task. When developing your own custom adapters, you must determine which categories your adapter needs to meet the goals of your development. For example,
Is your adapter going to be a standard or an Active Sync-enabled adapter?
Will the first phase of your deployment support password reset only?
How you answer these questions determines which resource methods must be completed.
The following table describes resource methods categories. (Additional information about each functional category is discussed later in this chapter.)Table 9–10 Resource Methods Categories
In Active Sync-enabled adapters, resource methods
Create a feed from the resource into Identity Manager. Presents methods that search the resource for changes or receive updates. To write these methods, you must understand how to register or search for changes on the resource, and communicate with the resource.
Run update operations in the Identity Manager repository by performing the feed from the resource into Identity Manager.
The following considerations are specific to account attributes in standard resource adapters:
User identity template
Creating an identity template out of multiple user attributes
Login configuration and pass-through authentication
To view or edit the Identity Manager schema for Users or Roles you must be a member of the IDM Schema Configuration AdminGroup and you must have the IDM Schema Configuration capability.
The user identity template establishes the account name to use when creating the account on the resource. This template translates Identity Manager user account information to account information on the external resource.
You can use any schema map attribute (an attribute listed on the left side of the schema map) in the identity template.
You can overwrite the user identity template from the User form, which is commonly done to substitute organization names.
You. Do not change this section of the file if you want the resource to appear in the options list.
Each <AuthnProperty> element contains the following attributes.Table 9–11 <AuthnProperty> Element Attributes
User management across forests is only possible when multiple gateways, one for each forest, are deployed. In this case, you can configure the adapters to use a predefined domain for authentication per adapter without requiring the user to specify a domain as follows:
Add the following authentication property to the <AuthnProperties> element in the resource object’s XML:
<AuthnProperty name=’w2k_domain’ dataSource=’resource attribute’ value=’MyDomainName’/>
Replace MyDomainName with the domain that authenticates users.
For more information about this property, see the Active Directory resource adapter documentation in Resource Reference.
Most resource login modules support both the Identity Manager Administrative interface and User interface. The following example shows how SkeletonResourceAdapter.java implements the <LoginConfigEntry> element:
The following example defines the supported LoginModule DATA_SOURCE options. In this example, a LoginConfig entry is taken from the LDAP resource adapter supplied by Identity Manager. The entry defines two authentication properties whose dataSource value, if not specified, is supplied by the user.
The next example shows a Login Config entry where the authentication property’s dataSource value is not supplied by the user. In this case, the value is derived from the HTTP request header.
The following example shows how prototypeXML defines fields displayed on the Create/Edit Resource page.
The Identity Manager Administrative interface displays the resource attributes for the default resource as specified.
The following sections describe how to profile and define prerequisites for standard resource adapters and Active Sync-enabled adapters.
Profiling a Standard Resource Adapter
Profiling an Active Sync-Enabled Resource Adapter
Use the following information to create a profile and define prerequisites for a standard resource adapter:
Select an Identity Manager adapter file that most closely resembles the resource type to which you are connecting.
See Table 9–12 for a brief description of the default Identity Manager resource adapter files supplied with a standard Identity Manager configuration.
Research user account characteristics and how these tasks are performed on the remote resource:
Authenticate access to the remote resource
Update users
Get details about the changed users
List all users on the system
List other system objects, such as groups, that are used in the listAllObjects method
Identify the minimum attributes needed to perform an action and all supported attributes.
Verify that you have the appropriate tools to support connection to the resource.
Many resources ship with a published set of APIs or a complete toolkit that can be used to integrate outside applications to the resource. Determine whether your resource has a set of APIs or whether the toolkit provides documentation and tools to speed up integration with Identity Manager. For example, you must connect to a database through JDBC.
Determine who can log in and search for users on the resource
Most resource adapters require and run an administrative account to perform tasks such as searching for users and retrieving attributes. This account is typically a highly privileged or super user account, but can be a delegated administration account with read-only access.
Determine whether you can extend the resource’s built-in attributes.
For example, Active Directory and LDAP both allow you to create extended schema attributes, which are attributes other than the standard Identity Manager attributes.
Decide which attributes you want to maintain in Identity Manager, determine what the attribute names are on the resource, and decide what to name the attributes in Identity Manager. These attribute names go in the schema map and are used as inputs to forms that are used to create a resource of that type.
When profiling an Active Sync-Enabled resource adapter, use the following information in addition to the considerations described in Profiling a Standard Resource Adapter:
When researching user account characteristics and how these tasks are performed on the remote resource, you must also:
Identify ways to search for changed users only
Determine which resource attributes or actions create events.
If the resource supports subscribing to notification messages when changes are made, identify which attribute changes you want to trigger the notification and which attributes you want in the message.
Decide which of the following actions Identity Manager should perform when the adapter detects an event on the source.
Create, update, or delete a user
Disable or enable an account
Update the answers used to authenticate a user
Update a phone number
Decide whether you want the adapter to be driven by events in the external resource or driven by specified polling intervals.
Before making your decision, you must understand how polling works in typical Identity Manager installations. Although some installations implement or are driven by external events, most Identity Manager deployment environments use a hybrid method.
Choose one of the following approaches:
Set up polling intervals where an Active Sync Manager thread calls the poll interface at a configurable interval or on a specified schedule. You can set polling parameters, including settings such as faster polling if work was received, thread-per-adapter or common thread, and limits on the amount of concurrent operations.
Set up an event-driven environment where the adapter sets up a listening connection, such as an LDAP listener, and waits for messages from the remote system. You can implement the poll method to do nothing, and set the polling interval to an arbitrary value, such as once a week. If updates are event-driven, the updates must have a guaranteed delivery mechanism, such as MQ Series, or synchronization is lost.
Implement a hybrid solution where external events trigger smart polling and the regular poll routine can recover from missed messages.
Smart polling adapts the poll rate to the change rate and polls infrequently unless changes are being made often. Smart polling balances the performance impact of frequent polling with the update delays of infrequent polling.
In this model, incoming messages are queued and multiple updates for a single object are collapsed into a single update, which increases efficiency. For example, multiple attributes can be updated on a directory, and each attribute triggers a message. The poll routine examines the message queue and removes all duplicates. The routine then fetches the complete object to ensure that the latest data is synchronized and that updates are handled efficiently.
After profiling the resource, identify classes and methods needed in your adapter:
Review the relevant Javadoc to determine which base classes and methods you can use as is and which you must extend. This javadoc is available on your Identity Manager CD in the REF/javadoc directory.
Create a list of methods that you must write and include in the Java file based on the resource to which you are connecting.
When creating an adapter, the most time-intensive task is writing your own methods to push information from Identity Manager to the resource or to create a feed from the resource to Identity Manager.
The Sun Resource Extension Facility Kit (REF Kit) is supplied in the /REF directory on the Identity Manager CD or install image. You can use the sample files and other tools in this REF Kit to jump-start the process of creating your own custom adapter.
The following table describes the contents of the REF Kit.Table 9–12 REF Kit Components
This section contains instructions for setting up your build environment.
Prerequisites:
You must install the JDK version required for your Identity Manager version. See “Supported Software and Environments” in the Identity Manager Release Notes for information.
After installing the JDK, you must install the REF Kit by copying the entire /REF directory to your system.
If you are working on Microsoft Windows operating system, use the following steps to set up your build environment:
Change directories to a new directory.
Create a file called ws.bat.
Add the following lines to this file:
Where you set:
JAVA_HOME to the path to where the JDK is installed.
WSHOME to the path to where the REF Kit is installed.
Save and close the file.
If. | http://docs.oracle.com/cd/E19225-01/820-5820/ahujk/index.html | CC-MAIN-2017-09 | en | refinedweb |
Maintain global, singletin list of registered MeshOps. More...
#include <MeshOpSet.hpp>
Maintain global, singletin list of registered MeshOps.
This class implements the list of registered MeshOps. It uses the singleton pattern to provide a single global list while avoiding issues with order of initialization of static objects.
This class is intended only for internal use in
MKCore. Access to this data maintained by this class should be done through static methods in the
MKCore class.
Definition at line 22 of file MeshOpSet.hpp.
Type of iterator to use with /c OpList.
Definition at line 42 of file MeshOpSet.hpp.
Type of list returned by reference from member methods.
Definition at line 39 of file MeshOpSet.hpp.
Private constructor for singleton pattern.
Definition at line 8 of file MeshOpSet.cpp.
Get index of MeshOpProxy.
Get index of MeshOpProxy. Throws exception if not found.
Definition at line 59 of file MeshOpSet.cpp.
Get singleton instance.
Definition at line 10 of file MeshOpSet.cpp.
Get MeshOpProxy by name.
Get MeshOpProxy by name. Throws exception if not found.
Definition at line 51 of file MeshOpSet.cpp.
Get MeshOpProxy by index.
Get MeshOpProxy by index. Throws exception if not found.
Definition at line 67 of file MeshOpSet.cpp.
Get MeshOpProxy by name.
Returns
allMeshOps.end() if not found.
Definition at line 42 of file MeshOpSet.cpp.
Get list of all MeshOps that can be used to generate mesh entities of the specified dimension.
Definition at line 49 of file MeshOpSet.hpp.
Get list of all mesh ops.
Definition at line 56 of file MeshOpSet.hpp.
Register a mesh op.
Register a new MeshOp. Will fail upon duplicate names unless proxy pointer is also the same (duplicate registration).
Definition at line 16 of file MeshOpSet.cpp.
List of all registered MeshOps.
Definition at line 102 of file MeshOpSet.hpp.
Lists of all registered indexed by dimension of generated entities.
Definition at line 104 of file MeshOpSet.hpp. | http://www.mcs.anl.gov/~fathom/meshkit-docs/html/classMeshKit_1_1MeshOpSet.html | CC-MAIN-2017-09 | en | refinedweb |
Details
- Type:
Bug
- Status: Resolved
- Priority:
Major
- Resolution: Fixed
- Affects Version/s: 1.3
- Fix Version/s: None
- Labels:None
Description
There appears to be an inifinite loop in org.apache.commons.jxpath.ri.NamespaceResolver.getPrefix(). While I haven't yet been able to create a minimal test app that reproduces the problem, the bug seems fairly self-evident from the code.
protected static String getPrefix(NodePointer pointer, String namespaceURI) { NodePointer currentPointer = pointer; while (currentPointer != null) { NodeIterator ni = currentPointer.namespaceIterator(); for (int position = 1; ni != null && ni.setPosition(position); position++) { NodePointer nsPointer = ni.getNodePointer(); String uri = nsPointer.getNamespaceURI(); if (uri.equals(namespaceURI)) { String prefix = nsPointer.getName().getName(); if (!"".equals(prefix)) { return prefix; } } } currentPointer = pointer.getParent(); } return null; }
The problem line is the last line in the loop: 'currentPointer = pointer.getParent();'. As the 'pointer' variable never changes, the value of 'currentPointer' never changes between loop iterations after the second iteration. Consequently if the namespace prefix is not found in the first two iterations, an infinite loop occurs. The problem seems to be resolved by changing that line to 'currentPointer = currentPointer.getParent();'.
Issue Links
- is duplicated by
JXPATH-140 Error in loop of NamespaceResolver
- Closed
Activity
- All
- Work Log
- History
- Activity
- Transitions
Agreed that the bug is self-evident on a code review.
Thanks for the report.
Committed revision 918623. | https://issues.apache.org/jira/browse/JXPATH-135 | CC-MAIN-2017-09 | en | refinedweb |
Content-type: text/html
pthread_condattr_destroy - Destroys a condition variable attributes object.
DECthreads POSIX 1003.1c Library (libpthread.so)
#include <pthread.h>
int pthread_condattr_destroy(
pthread_condattr_t *attr);
Interfaces documented on this reference page conform to industry standards as follows:
IEEE Std 1003.1c-1995, POSIX System Application Program Interface
Condition variable attributes object to be destroyed.
This routine destroys the specified condition variable attributes object--that is, the object becomes uninitialized.
Condition variables that were created using this attributes object are not affected by the deletion of the condition variable attributes object.
After calling this routine, the results of using attr in a call to any routine (other than pthread_condattr_init(3)) are unpredictable.
If an error condition occurs, this function returns an integer value indicating the type of error. Possible error return values are as follows: Successful completion The attributes object specified by attr is invalid.
None
Functions: pthread_condattr_init(3)
Manuals: Guide to DECthreads, Programmer's Guide delim off | https://backdrift.org/man/tru64/man3/pthread_condattr_destroy.3.html | CC-MAIN-2017-39 | en | refinedweb |
: (Score:3, Insightful)
You actually prefer XML???????
Re: (Score:1)
Using XML is like sticking your nuts in a vice and squeezing them until they burst. Although in the end it's still more pleasant than using: (Score:1)
How so, specifically? I've never had an issue with it, but then I don't use bullshit scripting languages that force me to do lots of XML processing, let my tools do it for me.
So maybe you should rephrase - if you're using c. 1992 scripting languages, XML is total shit.
Re: (Score:2)
Re: (Score:1)
Re: (Score:2)
But it's easier now.
Re: (Score:2)
But the problem is -- as I mentioned in a post further up the page -- that JSON throws away some data type information. So when I use JSON, I have to reconstruct some of my data types when I use from_json. But I don't have to do that with XML.
And that's definitely a problem with JSON, not Ruby.
Re: (Score:3, Interesting)
"The funny thing is that, at the end of the day, JSON and XML are the same thing, only syntactically different."
Yes, exactly. But XML is readable by people. JSON is not. Just try to read any big dataset in JSON, especially if it's minified. Good luck. At least with XML you have a shot.
Having said that: there are lots of good tools for converting from one to the other, so it could be a lot worse.
You make a good point about standards and validation, though, too. That's why business data interchanges are generally built on XML, and not JSON. Even though JSON is generally more efficient.
Re: (Score:1)
Yes, exactly. But XML is readable by people
No it isn't. Neither of them is. Not directly. They are *both* readable by humans with a good browser/editor. Tell the editor guys to get crackin' if they haven't already. When dealing with any format that's a hierarchy, you should be able to view the top level and click a little '+' or something to open it. Visual Studio even does that with C for cryin' out loud. Class graph browsers for C++ have been out for like... forever. I don't work with XML or JSO
Re: (Score:2)
"No it isn't. Neither of them is. Not directly."
Yes, it is. If you don't believe me, I have posted a link to a simple example below. Not only is the JSON harder to read, it throws away data type information unnecessarily.
"When dealing with any format that's a hierarchy, you should be able to view the top level and click a little '+' or something to open it."
This is old stuff. TextMate (just for one example), has been doing that for a long time. Here's an example [postimg.org]. Notice how the line numbers skip where the code is collapsed.
You can also open XML in Firefox, and again it does exactly the same thing: you can expand and collapse levels at will.
Re: (Score:2)
XML is much more mature. XML has standardized schemas, validation, querying, transformation, a binary format and APIs for interoperability from any language.
Which means that XML will still be around in 10 years, and can safely be used today for major projects.
Re: (Score:3)
Re: (Score:1)
IF the situation calls for HUMANS to read the data, I sure as hell do prefer XML. No contest. JSON is virtually unreadable.
Like I said: it's fine for computer data interchange, but when it comes to human intervention, give me XML any day.
I'm not claiming XML is perfect, by any stretch of the imagination. But when humans rather than computers need to deal with the data, it beats the shit out of JSON.
Re: (Score:1)
How is JSON hard to read? It's just lists of key/value pairs
Re: (Score:1, Insightful)
Really. Non of that totally unnecessary tag BS inherited from a printer definition spec (of all absurd things.) And key/value pairs are a hell of a lot easier to insert into a database in addition to being easier to read.
Re: (Score:3)
"Really. Non of that totally unnecessary tag BS inherited from a printer definition spec (of all absurd things.) And key/value pairs are a hell of a lot easier to insert into a database in addition to being easier to read."
Key-value pairs are a tiny subset of all data types. There are many data types that they have to struggle to represent very well. And when they try, the result (to the human eye) is a huge mess.
You're entitled to your opinion of course. But I think you're looking at it from a very narrow perspective. Have you ever actually had to program for the exchange of complex data sets? By that I mean something quite a bit more involved than a web store?
Re: (Score:2)
"Yes. I'm lucky LISP can parse XML since they are really only just a special case of S-Expressions. Once out of that horrid mess of printer tags it was much more straightforward to validate them and insert them in all their complexity into a nicely normalized relational database."
You are conflating XML and SGML. While technically XML is a subset of SGML, it doesn't contain "printer tags". It literally doesn't have any. XML tags are strictly data description.
Saying that XML is SGML is kind of like saying "car" is LISP. The former is a clearly-specified tool used for certain specific things. The latter is a generalized tool for many things. You wouldn't write an entire language like LISP to perform the function car performs. Nor would you write a specification like SGML (which does
Re: (Score:2)
"No it is not weird. XML is weird because it contains and is based on printer control cruft. Lots of printer control cruft. An unnecessary tag is a tag is a tag is a fucking tag."
It does nothing of the sort. XML is a data description language. It's parent language -- SGML -- had a LOT of printer specification stuff in it. But XML has NONE. Not one little bit.
Jeez, guy. Pick up a book.
"An unnecessary tag is a tag is a tag is a fucking tag."
Then show me how to do the same thing without those tags that you call "unnecessary". Where are you going to get the information necessary to validate your data?
I linked to an example further up the page. XML preserved the data type, while JSON just turns any data it doesn't understand into a stri
Re: (Score:2)
XML has structures, standards, validation and flexibility that JSON sorely lacks. As someone else wrote above, the main thing JSON has going for it is that it's already JavaScript. Big deal.
I linked to a clear example further up. XML preserved my simple data structure. JSON threw away information about my data that I would have to supply myself later, if I were to use JSON to
Re: (Score:2)
Neither JSON nor XML is easily writable without special tools.
YAML attempts to be writable, but the grammar and parser are huge and slow.
RSON [google.com] is a superset of JSON that is eminently readable/writable, and much simpler than YAML, allowing, for example, for human-maintained configuration files.
The reference Python parser operates about as fast as the unaccelerated Python library pure JSON parser.
Re: (Score:2)
"Neither JSON nor XML is easily writable without special tools. "
Sure they are. Take just about any object in Ruby and call [object].to_xml or [object].to_json.
More relevant to the discussion though, I think, is what someone else said above:
"XML has standardized schemas, validation, querying, transformation, a binary format and APIs for interoperability from any language. All JSON really has going for it is that it's already JavaScript."
I would have to say the same for RSON.
While it is true that they are syntactical versions of one another, XML is far less ambiguous. In a way, XML versus JSON is a lot like Java versus JavaScript. The former have more tightly defined specifications, and less ambiguity. (I.e., Java will not let you treat a string like an integer
Re: (Score:2)
But I guess I suck at that myself, since we're obviously not communicating properly.
Obviously there are libraries in all sorts of languages to read/write both.
Re: (Score:3)
You actually prefer XML???????
Yes, as I deal in data interchange all the time, XML is great as it allows schema definition/sharing (XSD) and XSLT is a mature transformation language, that, after many years in the woods, is now available with functional capabilities (XSLT v3.0).
The only problem we have is that often, endpoint partners/vendors don't provide the XSD, nor do they share how they plan to validate files we send them. Or they ignore our XSD. But I still can't imagine things would be better if JSON were the interchange format.
Re: (Score:2)
Re: (Score:2)
Does JSON support namespaces? AFAIK it doesn't, and that would seem to make it suitable only for fairly simple data interchange and not really scalable. if it is a bit ugly!
I know it's bad-form replying to my own post, but it does appear that there is some kind of namespacing going on in the OData spec [oasis-open.org]. Does anyone know if this namespacing is part of the JSON standard, or is it just a convention that OASIS are using?
:D
Eitherway, I still prefer XML!
Re: (Score:1)
Yay! (Score:3)
Good!!!
}
They cracked the code on good web programming standards lol.
Re: (Score:1)
If (PlatformIndepenentProgrammingRelated == True) And (RelatedToJava == False) {
Good!!!
}
They cracked the code on good web programming standards lol.
string message = "";
If (PlatformIndepenentProgrammingRelated &&
!RelatedToJava)
{
message = "Good!!";
}
Re: (Score:1)
std::string message because I hate the guy who gets stuck maintaining things
Considering its the std:: c++ library, you should enable it correctly in stdafx.h for your whole project.
#include
using namespace std;
Re: (Score:2)
Ok, you have types with leading lowercase letters, variables with both leading uppercase and lowercase letters, an "If" keyword with a captial "I" as in Microsoft BASIC, and you initialize a string unnecessarily. Please turn in your geek cred card.
:-)
He's logged in with a Google+ account. He never HAD one. In fact he actually likes beta!
Re: (Score:1)
Ok, you have types with leading lowercase letters, variables with both leading uppercase and lowercase letters. with a captial "I"
Copy and paste for the win.
and you initialize a string unnecessarily.
Necessarily, i initialize the string correctly and give it a NULL value, before i go ahead and play with it.
I'd love to see the values of your variables. Wonder how many of them are uninitialized and causing havoc in your code.
Re: (Score:2)
O'Data (Score:5, Funny)
An Irish android? How appropriate!
I'm not clear.... (Score:2)
I'm not clear here, isn't that the purpose of TCP/IP?
Re: (Score:2)
TCP is for reliable in order transmission/reception of octects.
Re: (Score:2)
TCP is for reliable in order transmission/reception of octects.
...and standardizes nothing about the content of those octets, so, as you suggest, TCP, by itself, is insufficient to "[simplify] data sharing across disparate applications in enterprise, cloud, and mobile devices".
Oh the irony (Score:4, Interesting)
At the link for the specifications OData JSON Format Version 4.0 [oasis-open.org]
The documents that are tagged as Authoritative are
.doc, not even .docx
Re: (Score:2, Interesting)
Oh the irony
History, not irony.
Microsoft took over OASIS in 2006 as part of their campaign to scuttle open document formats. They're still running the show there.... [zdnet.com]
Reinvention of RDF + SPARQL (Score:2)
Re: (Score:3)
SPARQL appears to be read only, and to be restricted to data in kvp or 3-tuples.
OData supports mutable entities, change and request batching, and http GET semantics for data access. It would appear to map much better to real-world databases and business use-cases.
Re: (Score:3)
Re: (Score:2)
You could be right.
OData predates SPARQL 1.1, however, and supported all CRUD operations from its inception.
Re: (Score:1)
What is OData? Why should you care? (Score:5, Informative)
OData is (now) a standard for how applications can exchange structured data, oriented towards HTTP and statelessness.
OData consumers and producers are language and platform neutral.
In contrast to something like a REST service, for which clients must be specifically authored and the discovery process is done by humans reading an API doc, ODATA specifies a URI convention and a $metadata format that means OData resources are accessed in a uniform way, and that OData endpoints can have their shape/semantics programmatically discovered.
So for instance, if you have entity named Customer hosted on [foo.com], I can issue an HTTP call like this:
GET... [foo.com]
and get your customers.
furthermore, the metadata document describing your customer type will live at
foo.com/myODataFeed/$metadata
... which means I can attach to it with a tool and generate proxy code, if I like. It makes it easy to build a generic OData explorer type tool, or for programs like Excel and BI tools to understand what your data exposes.
Suppose that your Customers have have an integer primary key, (which I discovered from reading $metadata), and have a 1:N association to an ORders entity. I can therefore write this query:
GET... [foo.com]
.. and get back the Orders for just customer ID:1
I can add additional operators to the query string, like $filter or $sort, and data-optimization operators like $expand or $select.
OData allows an arbitrary web service to mimic many of the semantics of a real database, in a technology neutral way, and critically, in a way that is uniform for anonymous callers and programmatically rigorous/discoverable.
Examples of OData v3 content are available here:... [odata.org]
OData V4 is a breaking protocol change from V3 and prior versions, but has been accepted as a standard
And, shameless plug: If you want to consume and build OData V1/V2/V3 services easily, check out Visual Studio LightSwitch
:)
Re: (Score:2)
Sounds neat but doesn't solve my JSON problems.
One project might use "customer" another "client" or "businessname". Each of these may have a "description", "overview", "synopsis" and a "type"/"kind"/"businesstype" field.
So code discovery of data doesn't work unless we have agreed to standardized field names in advance, but now there's always exceptions to look out for and name conflicts.
Now even if we know the names of every field, how do we know exactly what sort of data will be returned? A name alone is
Re: (Score:2)
I suggest you look at the $metadata document for the service I linked to.
The property names, conceptual storage types, relationship info, etc, is all in there.
I'm not sure what problem you're trying to solve, exactly.
Then use XML (Score:2).
JSOAP? (Score:1)
Microsoft. (Score:2)
Know who leads the OData brigade? Microsoft. Get your crying ready, neckbeards.
On a more serious note, OData is awesome. If you've ever tried to provide a good data query API (supporting boolean syntax arbitrary queries) via a web service it's not easy. OData does it very well.
Sure, you'll get some whining from people who don't understand it that it forces you to expose your data model to the outside world, but it does absolutely no such thing. You can, should you choose, expose a complete abstraction
Re: (Score:2)
Sold!!! (Score:1)
REST buzzword (Score:2)
Representational state transfer
- from wikipedia
its a framework ? | https://news.slashdot.org/story/14/03/17/1720214/oasis-approves-odata-40-standards-for-an-open-programmable-web | CC-MAIN-2017-39 | en | refinedweb |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.