Note: There are many sales that are unreported each month. We cannot comment on the unknown, so we deal with what’s reported to and by reliable sources.

New Gtld domain sales for October 2023 come in just below $1M

DomainingTips.com: Today: Looking for Dot Com – Budget $1,500 / Edelweiss.com Sold for $27,587 / Dot Xyz Wanted – Budget Above $100 / and More… Here are the new discussions that caught my eye in the domain community today: Looking for Dot Com ...

Deceivers.com Appraised for $6,499

Service leverages Dan.com checkout and Afternic’s transfer/payment service. Afternic now offers checkout links for selling domains directly. Afternic has launched “custom checkout links” that allow domain sellers to use Afternic’s transfer service ...

Afternic launches “bring your own sale” links that work with long term payments

Back in June GoDaddy had the top sale with SsangYong.com which sold for $46,000. Interestingly the name closed at $7,200 in 2022 at GoDaddy auctions. There is a Wikipedia page for the SsangYong Group.

That’s a nice rollback, $46,000 to $135 on SsangYong.com

A super premium domain name such as Main.com should never be renewed on a year to year basis. Main.com was registered in November 1994, at a time when all domain registrations were free. As far as we can tell, the domain name Main.com has been register ...

Main.com

Donald A. DiRosa

Afternic tweeted out their June 2023 top keywords list. My actually took the top spot followed by AI and Group. Looking at Sedo’s trending list for June 2023 My and Group do not make the list, while AI and Bet are also in the top 10 as well.

Afternic Top 20 Keywords sold for June 2023

Ambre.com sold for the third time in 15 years. According to BabyNames.com Ambre is primarily a female name of French origin that means Amber (Fossilized Tree Resin). French form of the name Amber. In 2008 the domain name sold for $2,

Ambre.com transacts publicly for a third time

A nice .org expired on GoDaddy auctions today. Miss.org sound like a title PIR could run for a national spokeswoman. The domain name sold back in 2011 for just $2,105 at Sedo, ( a retail purchase). Today the domain auction closed over 4 times higher at $8,702.

Miss.org expires and goes for 4x what it sold for back in 2011

Earlier in the week I posted Sedo’s top trending keywords for June and AI was the top spot. Afternic tweeted out their top keyword in domains sold at Afternic for May.

AI is tops in May at Afternic when it comes to top keywords sold

Afternic

fabrick

Web3: A Decentralized Social Fabric?

COPA v. Wright, Court Filing, retrieved on January 29, 2024, is part of HackerNoon’s Legal PDF Series. You can jump to any part of this filing here. This part is 31 of 42. 29. “Noncooperative finite games” (Reliance Document) {ID_000396} / {L3/203/1} 544. This document purports to be precursor work to the Bitcoin White Paper relating to network theory and mentioning “bitcoin”. It is dated to 10 September 2008. (a) COPA’s Reasons for Alleging Forgery 545. The document has been backdated. [PM27 [38]]. 546. The document was created within 3 minutes after {ID_000395}, another “Lynn Wright document” bearing independent indicia of tampering. [PM27 [17.a.]]. 547. The document was created in the same user session as {ID_000371}, another “Lynn Wright document” which contains common content as well as independent indicia of tampering. 548. Along with {ID_000371}, this document was created by copying content from an intermediate document deriving from a publicly available source document. [PM27 [18- 25]]. 549. The document contains a redundant reference section listing sources which do not relate to the main body content of the document. [PM27 [20]]. 550. The document contains hidden, embedded text of previous editing history, including comments which have since been deleted from the document. Among the embedded text is a series of comments dating from 22 October 2008. However, that was some 6 weeks in the future at the purported Created and Last Modified date in the internal metadata of the file. [PM27 [26-30]]. 551. The document has an edit time of 1 minute, but the content within the document would have taken longer to create, indicating that the content was imported from a donor source [PM27 [13-15]]. No donor source document has been disclosed. 552. The document was conducted by an unlikely sequence of saves between two authors in two minutes. [PM27 [5-6]]. 553. The document editing period overlaps with other similar documents in Dr Wright’s disclosure. [PM27 [32]]. (b) COPA’s Reasons for Inferring Dr Wright’s Knowledge / Responsibility 554. Dr Wright is recorded as an author within the metadata of this document. 55. Dr Wright has positively asserted that this is a document on which he primarily relies as supporting his claim to be Satoshi Nakamoto. 556. In his evidence in these proceedings, Dr Wright relies on purported work of the type referred to in this document as “foundational” for Bitcoin. [Wright1 [53-54]]. 557. The effect of the tampering is therefore to make the document appear to be supportive of Dr Wright’s claim to be Satoshi Nakamoto (suggesting work by Dr Wright on a subject of interest to him, but with reference to Bitcoin), contrary to fact. 558. In these proceedings (and previously), Dr Wright has claimed that his development of Bitcoin was influenced by work on networks as referred to in at least the references section of this document. It is to be inferred that this forgery was done to support that aspect of his claim. [Wright1 [54]]. 559. Dr Wright has not disclosed the donor document or intermediate source document from which the content of {ID_000396} has been generated. 560. In his first witness statement in these proceedings, Dr Wright lists this document as a document to which he has been referred when preparing his evidence. (c) Dr Wright’s Explanations and COPA’s Rebuttal 61. In Appendix B to Wright11, Dr Wright sought to explain away the embedded text in the metadata containing a date / time reference for 22 October 2008 by saying that, while the document was created in September 2008, it could have been accessed in December 2008. He suggested that a user on a shared computing environment could have accessed the document, causing that reference to be inserted, but not interacted with the document (even to save it), thus accounting for the last saved timestamp remaining at 10 September 2008. See {CSW/2/40}. 562. In Appendix B to Wright11, Dr Wright sought to explain the anomalous edit time of just one minute by claiming that the document was produced by extremely quick cut-andpaste operations. See {CSW/2/42}. 563. In the relevant section of Appendix B, Dr Wright did not address the fact that this document featured a list of references at the end despite the text not actually referring to any of the reference works. That list of references originated in a paper by Olfati-Saber, from which Dr Wright copied when creating another of his documents: {ID/000371}: see PM27 [18-24]. 564. COPA submitted that Dr Wright’s explanation should be rejected as dishonest for the following reasons: 564.1. Dr Wright’s explanation for the presence of the date / time reference is contradicted by the clear expert evidence of Mr Madden, which is that such a reference could not be inserted without the document being interacted with by a user, which would in turn result in updating of the metadata timestamps of the document. The presence of the anachronistic reference shows that the document has been forged by backdating. See Madden4, [158]; Madden / Placks joint statement 2 at [8]; {Day16/35:19} to {Day16/38;11}; {Day16/125:7} to {Day16/125:18}. 564.2. On Dr Wright’s account, he created this document within just one minute by cutting and pasting sections from other (unidentified and apparently undisclosed) documents. It is implausible that he would produce a genuine research paper in this way. It is also highly unlikely that he would remember this method of creation 15 years on without having access to, and being able to identify, the underlying documents. 564.3. Dr Wright has failed to give any account for his addition to this document of a references section consisting entirely of works not referenced in the body of the text. The fact that this section matches a section from another of his document, which in turn copied from a published work, supports COPA’s case that this is another forgery produced in haste. (d) Conclusion 565. The points made by and on behalf of Dr Wright do not begin to provide a viable alternative explanation to the detailed points made by COPA. Once again, I find this document was plainly forged by Dr Wright. Continue Reading Here. About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings.

This court case retrieved on January 29, 2024, judiciary.uk is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. COPA v. Wright, Court Filing, retrieved on January 29, 2024, is part of HackerNoon’s Legal PDF Series. You can jump to any part of this filing here. This part is 31 of 42. COPA v. Wright, Court Filing, retrieved on January 29, 2024, is part of HackerNoon’s Legal PDF Series . You can jump to any part of this filing here . This part is 31 of 42. HackerNoon’s Legal PDF Series HackerNoon’s Legal PDF Series here here 29. “Noncooperative finite games” (Reliance Document) {ID_000396} / {L3/203/1} 544. This document purports to be precursor work to the Bitcoin White Paper relating to network theory and mentioning “bitcoin”. It is dated to 10 September 2008. (a) COPA’s Reasons for Alleging Forgery (a) COPA’s Reasons for Alleging Forgery 545. The document has been backdated. [PM27 [38]]. 546. The document was created within 3 minutes after {ID_000395}, another “Lynn Wright document” bearing independent indicia of tampering. [PM27 [17.a.]]. 547. The document was created in the same user session as {ID_000371}, another “Lynn Wright document” which contains common content as well as independent indicia of tampering. 548. Along with {ID_000371}, this document was created by copying content from an intermediate document deriving from a publicly available source document. [PM27 [18- 25]]. 549. The document contains a redundant reference section listing sources which do not relate to the main body content of the document. [PM27 [20]]. 550. The document contains hidden, embedded text of previous editing history, including comments which have since been deleted from the document. Among the embedded text is a series of comments dating from 22 October 2008. However, that was some 6 weeks in the future at the purported Created and Last Modified date in the internal metadata of the file. [PM27 [26-30]]. 551. The document has an edit time of 1 minute, but the content within the document would have taken longer to create, indicating that the content was imported from a donor source [PM27 [13-15]]. No donor source document has been disclosed. 552. The document was conducted by an unlikely sequence of saves between two authors in two minutes. [PM27 [5-6]]. 553. The document editing period overlaps with other similar documents in Dr Wright’s disclosure. [PM27 [32]]. (b) COPA’s Reasons for Inferring Dr Wright’s Knowledge / Responsibility (b) COPA’s Reasons for Inferring Dr Wright’s Knowledge / Responsibility 554. Dr Wright is recorded as an author within the metadata of this document. 55. Dr Wright has positively asserted that this is a document on which he primarily relies as supporting his claim to be Satoshi Nakamoto. 556. In his evidence in these proceedings, Dr Wright relies on purported work of the type referred to in this document as “foundational” for Bitcoin. [Wright1 [53-54]]. 557. The effect of the tampering is therefore to make the document appear to be supportive of Dr Wright’s claim to be Satoshi Nakamoto (suggesting work by Dr Wright on a subject of interest to him, but with reference to Bitcoin), contrary to fact. 558. In these proceedings (and previously), Dr Wright has claimed that his development of Bitcoin was influenced by work on networks as referred to in at least the references section of this document. It is to be inferred that this forgery was done to support that aspect of his claim. [Wright1 [54]]. 559. Dr Wright has not disclosed the donor document or intermediate source document from which the content of {ID_000396} has been generated. 560. In his first witness statement in these proceedings, Dr Wright lists this document as a document to which he has been referred when preparing his evidence. (c) Dr Wright’s Explanations and COPA’s Rebuttal (c) Dr Wright’s Explanations and COPA’s Rebuttal 61. In Appendix B to Wright11, Dr Wright sought to explain away the embedded text in the metadata containing a date / time reference for 22 October 2008 by saying that, while the document was created in September 2008, it could have been accessed in December 2008. He suggested that a user on a shared computing environment could have accessed the document, causing that reference to be inserted, but not interacted with the document (even to save it), thus accounting for the last saved timestamp remaining at 10 September 2008. See {CSW/2/40}. 562. In Appendix B to Wright11, Dr Wright sought to explain the anomalous edit time of just one minute by claiming that the document was produced by extremely quick cut-andpaste operations. See {CSW/2/42}. 563. In the relevant section of Appendix B, Dr Wright did not address the fact that this document featured a list of references at the end despite the text not actually referring to any of the reference works. That list of references originated in a paper by Olfati-Saber, from which Dr Wright copied when creating another of his documents: {ID/000371}: see PM27 [18-24]. 564. COPA submitted that Dr Wright’s explanation should be rejected as dishonest for the following reasons: 564.1. Dr Wright’s explanation for the presence of the date / time reference is contradicted by the clear expert evidence of Mr Madden, which is that such a reference could not be inserted without the document being interacted with by a user, which would in turn result in updating of the metadata timestamps of the document. The presence of the anachronistic reference shows that the document has been forged by backdating. See Madden4, [158]; Madden / Placks joint statement 2 at [8]; {Day16/35:19} to {Day16/38;11}; {Day16/125:7} to {Day16/125:18}. 564.2. On Dr Wright’s account, he created this document within just one minute by cutting and pasting sections from other (unidentified and apparently undisclosed) documents. It is implausible that he would produce a genuine research paper in this way. It is also highly unlikely that he would remember this method of creation 15 years on without having access to, and being able to identify, the underlying documents. 564.3. Dr Wright has failed to give any account for his addition to this document of a references section consisting entirely of works not referenced in the body of the text. The fact that this section matches a section from another of his document, which in turn copied from a published work, supports COPA’s case that this is another forgery produced in haste. (d) Conclusion (d) Conclusion 565. The points made by and on behalf of Dr Wright do not begin to provide a viable alternative explanation to the detailed points made by COPA. Once again, I find this document was plainly forged by Dr Wright. Continue Reading Here. Continue Reading Here . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case retrieved on January 29, 2024, judiciary.uk is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case retrieved on January 29, 2024, judiciary.uk is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. judiciary.uk judiciary.uk

Craig Wright’s Bitcoin-Related Document Exposed as Fabricated

COPA Presents Evidence of Bitcoin White Paper Fabrication by Craig Wright 

COPA Claims Craig Wright’s LaTeX Documents on Bitcoin Concepts are Fabricated

This paper is available on arxiv under CC 4.0 license. Authors: (1) Terence Blésin, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL); (2) Wil Kao, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL); (3) Anat Siddharth, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL); (4) Alaina Attanasio, OxideMEMS lab, Purdue University; (5) Hao Tian, OxideMEMS lab, Purdue University; (6) Sunil A. Bhave, OxideMEMS lab, Purdue University; (7) Tobias J. Kippenberg, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL). Table of Links Introduction Results A. Physics and design B. Device characterization C. Bidirectional microwave-optical transduction D. Pulsed transduction Discussion Acknowledgments Appendix A: Theory Appendix B: Fabrication process flow Appendix C: Optical characterization Appendix D: Characterization of acoustic resonances Appendix E: Characterization of bidirectional transduction Appendix F: Optimization of optical extraction efficiency Appendix B: Fabrication process flow The piezoelectric actuators are monolithically integrated on Si3N4 waveguides, fabricated using the photonic Damascene process [7, 8]. The 850-nm-thick Si3N4 film is deposited using low-pressure chemical vapor deposition into the Damascene preform, with 2.8 µm thermal oxide below the waveguides. After annealing to drive hydrogen impurities out of the Si3N4 layer, 2.1-µm-thick TEOS oxide and 1.0-µm-thick low-temperature oxide top claddings are deposited and subsequently annealed. The metallic and piezoelectric films—95 nm of Mo, 1.0 µm of AlN and another 95 nm of Mo—are sputtered through foundry services provided by Plasma-Therm [9]. They are then patterned using deep reactive ion etching (DRIE) to form the actuators, ground planes and integrated heaters. We employ the same BandAid process as in Ref. [10] to localize the electrodes atop the suspended cladding. In particular, when connecting the Al feedline to the top electrode by a lift-off process, the bottom electrode is etched back using XeF2 to avoid shortcircuiting the electrodes. The process to suspend the cladding in the vicinity of the actuator is combined with the chip singulation steps of the Damascene process. First, a hole is opened in the middle of the donut-shaped actuator. The chip facets are simultaneously defined where trenches in the SiO2 are etched by C4F8 DRIE between neighboring chips. A second photolithography is performed to protect the facets while leaving the etched holes exposed for further processing, resulting in narrower trenches between chips. The Si substrate is then isotropically etched with SF6 until the SiO2 cladding below the actuator is suspended [11]. Following cladding suspension, the Si substrate is etched anisotropically until the desired chip thickness of 250 µm is reached. A final isotropic Si etch removes the parts of the substrate protruding from the SiO2 facet, providing proper access to the bus waveguide nanotapers with lensed fibers, or even using the butt-coupling scheme. To facilitate this last step, we employ ion-beam etching at a 20◦ tilt angle to remove the passivation layer formed on the hole sidewalls during the Si DRIE. The chips are ultimately released by grinding the back side of the wafer. This convoluted process ensures that all the actuators on the wafer are fully suspended, while the chip facets do not become exceedingly fragile from the undercut.

Bidirectional Microwave-optical Transduction Based on Integration: Appendix B: Fabrication

Scientific American Supplement, No. 717, September 28, 1889, by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . NATURE, COMPOSITION, AND TREATMENT OF ANIMAL AND VEGETABLE FABRICS. here NATURE, COMPOSITION, AND TREATMENT OF ANIMAL AND VEGETABLE FABRICS. The inseparable duties of studying the composition of the various animal and vegetable fabrics, as also their nature—when in contact with the various mineral, vegetable, animal, and gaseous bodies applied in the individual industries—should not devolve upon the heads, chemists, or managers of firms alone. It is most important that every intelligent workman, whom we cannot expect to acquire a very extensive knowledge of chemistry and perfect acquaintance of the particular nature and component parts of fabrics, should, at least, be able to thwart the possibility of the majority of accidents brought about in regard to the quality and aspect of materials treated by them. In the treatment of wool the first operations are of no mean importance, and the whole subsequent operations and final results, almost as a whole, depend on the manner in which the fleece washing had been effected. In presence of suintine, as also fatty matters, as well as the countless kinds of acids deposited on the wool through exudation from the body, etc., the various agents and materials cannot act and deposit as evenly as might be desired, and the complete obliteration of the former, therefore, becomes an absolute necessity. For vegetable fabrics a great technical and practical knowledge is already requisite in their cultivation itself, and before any operations are necessary at all. One of the greatest points is the ripeness of the fibers. It is almost an impossibility to produce delicate colors on vegetable fabrics which were gathered inopportunely. Numerous experiments have been made on cotton containing smaller or larger quantities of unripe fibers, and after the necessary preceding operations, have been dyed in rose, purple, and blue colors, and the beauty of the shades invariably differed in proportion to the greater or lesser quantities of unripe fibers contained in the samples, and by a careless admixture of unripe and unseasoned fibers the most brilliant colors have been completely spoiled in the presence of the former. These deficiencies of unripe vegetable fibers are so serious that the utmost precautions should be taken, not only by planters to gather the fibers in a ripe state, but the natural aspect of ripe and unripe fibers and their respective differences should be known to the operators of the individual branches in the cotton industry themselves. The newest vegetable fabrics, as (China grass), pina, , or Manila hemp, , jute, and that obtained from the palm tree, must be tended with equal care to that of cotton. The , or China grass, is obtained from the , as also from the less known . The fibers of this stalk, after preparing and bleaching, have the whiteness of snow and the brilliancy of silk. By a special process—the description of which we must for the present leave in abeyance—the China grass can be transformed into a material greatly resembling the finest quality of wool. The greatest advantage afforded in the application of China grass is, moreover, that the tissues produced with this fiber are much more easily washed than silks, and in this operation they lose none of their beauty or their quality. ma abaca agave ma Boehmeria nivea Boehmeria puya The is produced from the fibrous parts of the bark of the wild banana tree, found in the Philippines. Its botanical denomination is . The fiber is not spun or wrung, but is jointed end to end. The threads are wound and subsequently beaten for softening, and finally bleached by plunging in lime water for twenty-four hours, and dried in the sun. abaca Musa troglodytarum abaca The is a fiber obtained from the leaf of the anana tree ( ), and is prepared in the same way as the abaca, but extreme care must in this case be observed in culling the fibers, in order to sort in accordance with their degree of fineness. pina Bromelias ananas The Arabs manufacture the stuff for their tents with a mixture of camel's hair and the fibrous flocks (kind of wadding) obtained from the stalks of the wafer palm (the ). Chamærops humilis The tissues used by the Arabs are coarse and colored, but the palm fibers—when freed from gluten, which makes them adhere more strongly—are susceptible to divide in a most astonishing manner. The is a coarse fiber, mostly used in France for the manufacture of Gobelin carpets and the production of ropes. Great efforts have been made to bleach it in a satisfactory manner, as is done with the , but the former kind of fiber resists the ordinary treatment with lyes, etc., and an appropriate bleaching process has only been discovered quite recently. Agave americana Phormium tenax Jute, which by many is confounded with , or New Zealand lint, is a fiber which can be divided as finely as desired, and can be most beautifully bleached. Phormium tenax The jute or Indian is generally known as a fibrous and textile fabric, obtained chiefly from Calcutta, and is similar in nature to the , an Oriental species, known in Oriental India by the name of and . This fibrous plant has the property of dividing into the finest parallel fibers, which can be carded without difficulty, and may be said to have the excellent properties of linen, hemp, and cotton at once. When properly bleached, it has an aspect which is as beautiful as that of silk. A mixture of silk and jute can be easily worked together, and can also be mixed with such vegetable fibers as cotton and linen. An immense quantity of flannel and other stuffs are now manufactured and imitated with the different mixtures containing jute. paat Corchorus capsularis hatta jute gheenatlapaat The is a fiber of a plant in the form of a cane ( ), and the paat or is the thread of a species of spiral ( ), sold under the name of jute tissues. suun Crotalaria juncea suncheepaat Corchorus olitarius The cotton tissues lose about twenty-five per cent. of their weight in bleaching, five per cent. of the substances are dissolved through alkalies, and the other twenty per cent., which are not attacked directly through the alkalies, are removed through chlorine, acids, and the water itself. The linen and hemp tissues contain eighteen per cent. of substances which are soluble in alkalies, and they lose from twenty-seven to thirty per cent. of their weight when taken through the consecutive bleaching operations. The substances do not alone include the substances contained in the fabric originally, but also such as are deposited in the preliminary treatment of the fabrics, as dirt from the hands of the operator, and gluten soluble in warm water; as also glue or gelatine, potash or soda, starch, albumen, and sugar, used by weavers, etc., and which are all soluble in water; further, such as greasy matters, calcareous soap, coppery soap, resinous or gummo-resinous matters, and the yellow and green coloring matters contained in textile fabrics, which are soluble in caustic soda; and finally, the earthy constituents which are soluble in acids. The nature and composition of silk and wool is diametrically opposed to that of the former. The silk is more of a gummy nature, and is susceptible to decompose into a kind of gelatinous mass if specially treated. The yellow coloring principle in silk was found only to be contained in a very small proportion, and consisting of several distinct bodies. The wool contains, first, a fatty matter which is solid at an ordinary temperature, and perfectly liquid at 60° C.; secondly, a fatty matter which is liquid at 15° C.; thirdly, a fibrous substance which essentially constitutes the wool in the strict sense of the word. The wool at least contains three important principles, as it will be known that the fibrous substance disengages sulphur and hydro-sulphuric acid without losing its peculiar properties; and it, therefore, appears probable that the sulphur entered as an element in the composition of a body which is perfectly distinct from the fibrous substance aforementioned. In treating wool with nitric acid, and taking all possible precautions to determine as accurately as possible the quantity of sulphuric acid produced by the contents of sulphur in the wool by the reaction with chloride of barium, it will be found to contain from 1.53 to 1.87 per cent. of sulphur.— Wool and Textile Fabrics. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various (2006). Scientific American Supplement, No. 717, September 28, 1889. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/17755/pg17755-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

NATURE, COMPOSITION, AND TREATMENT OF ANIMAL AND VEGETABLE FABRICS

Scientific American Supplement, No. 799, April 25, 1891 by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . STARCHES FOR THE FINISHING OF COTTON FABRICS. here STARCHES FOR THE FINISHING OF COTTON FABRICS. The starches have been classified by Dr. Muter, according to the appearance they give under the microscope, into five groups: .—Hilum and concentric rings visible. All the granules, oval or ovate. Tous-le-mois, potato, arrowroot, etc. Class I .—The concentric rings are all but invisible, the hilum is stellate. Maize, pea, bean, etc. Class II .—The concentric rings are all but invisible, also the hilum in the majority of granules. Wheat, barley, rye, chestnut, etc. Class III .—All the granules truncated at one end. Sago, tapioca, etc. Class IV .—All the granules angular in form. Rice, tacca, arrowroot, oats, etc. Class V The principal starches used for finishing cotton fabrics are potato (farina), wheat, Indian corn (maize), rice, tapioca, arrowroot, sago; the last three not so often as those previously named. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various (2004). Scientific American Supplement, No. 799, April 25, 1891. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/11649/pg11649-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

STARCHES FOR THE FINISHING OF COTTON FABRICS

Fabric.js is a powerful library for handling Canvas interactions and rendering. While it's already a performant library, there are certain techniques you can employ to further improve the interaction and rendering speed. In this article, we will explore some valuable tips for optimizing performance in Fabric.js. Content Overview Utilize renderonAddRemove EnlivenObjects instead of loadFromJSON Optimize by excluding non-interactive shapes Utilize fabric.StaticCanvas Fine-tune object properties Enable object caching Use requestAnimationFrame Minimize Redraws Use object grouping Limit object complexity Use event delegation for interactivity Optimize rendering performance with fabric.util.requestRenderAll() Optimize image loading with lazy loading Dispose of unused objects and canvases Utilize renderOnAddRemove One of the recommended tips for optimizing performance in Fabric.js is to set the property to false when initializing the canvas. By adding to the fabric.Canvas constructor, you prevent Fabric from rerendering the entire canvas whenever an object is added or removed. renderOnAddRemove { renderOnAddRemove: false } This significantly improves performance during the initial load when adding multiple shapes to the canvas. const canvas = new fabric.Canvas("myId", { renderOnAddRemove: false });
canvas.renderAll(); // Call this whenever you want changes to be visible on the canvas EnlivenObjects instead of loadFromJSON While is a useful function for JSON to the canvas, it has some drawbacks. It clears the canvas before loading the JSON objects and automatically calls renderAll, which can be inefficient if you have additional operations to perform afterward. loadFromJSON deserializing Instead, you can use the function to parse the serialized Fabric.js JSON and add the objects to the canvas manually. enlivenObjects The rendering can be controlled more easily this way. const canvas = new fabric.Canvas("myId", { renderOnAddRemove: false });
fabric.util.enlivenObjects([{}, {}, {}], (objs) => {
    objs.forEach((item) => {
        canvas.add(item);
    });
    canvas.renderAll(); // Make sure to call this once you're ready!
}); Optimize by excluding non-interactive shapes Imagine you have a Fabric.js canvas with multiple shapes, but some of them are static and don't need to be interacted with. You can convert those non-interactive layers into image representations. Here's an example: // Convert non-interactive layers to images
var nonInteractiveLayer = new fabric.Rect({
    width: 200,
    height: 200,
    fill: 'red'
});
var image = new Image();
image.src = canvas.toDataURL('png');

// Render the image as an HTML <img> tag
document.body.appendChild(image);

// Overlay the canvas on top of the image
canvas.setOverlayImage(image, canvas.renderAll.bind(canvas)); By rendering non-interactive layers as images, you reduce the workload on Fabric.js and improve performance. Utilize fabric.StaticCanvas If you don't need interactivity in your canvas, you can use fabric.StaticCanvas instead of . fabric.Canvas Here's an example: // Create a static canvas
var staticCanvas = new fabric.StaticCanvas('myCanvas');

// Add objects to the static canvas
var rect = new fabric.Rect({
    width: 100,
    height: 100,
    fill: 'blue'
});
staticCanvas.add(rect);

// Perform other operations on the static canvas
// ...

// Render the static canvas
staticCanvas.renderAll(); Using instead of improves performance by avoiding the rendering of controls, borders, and corner detection. fabric.StaticCanvas fabric.Canvas Fine-tune object properties To optimize performance, you can fine-tune certain properties of objects in Fabric.js. Here are some examples: // Disable selection for an object
object.selectable = false;

// Disable controls and borders for an object
object.hasControls = false;
object.hasBorders = false;

// Disable rotating point for an object
object.hasRotatingPoint = false;

// Disable selection for the entire canvas
canvas.selection = false;

// Toggle skipTargetFind for mouse movement optimization
canvas.skipTargetFind = true; // or false, depending on your needs By adjusting these properties, you can improve performance by avoiding unnecessary rendering of controls, borders, and object corner detection during mouse movement. Enable object caching Fabric.js provides automatic object caching, where objects are pre-painted on an offscreen canvas and then copied onto the main canvas during the rendering process. Object caching can significantly improve performance, especially when dealing with complex objects or large SVGs. By default, object caching is enabled in Fabric.js. You can customize the caching behavior using the following properties: : When set to , objects are cached on an additional canvas. By default, this property is for browsers and for Node.js. objectCaching true true false : When set to , Fabric.js checks object properties for cache invalidation. If disabled, you may need to manually invalidate the cache when necessary. By default, this property is . statefulCache true false : When set to , cache regeneration is disabled during scaling operations. This can help avoid blurry effects during scaling. By default, this property is . noScaleCache true true : This flag indicates whether the object's cache needs to be rerendered. It is automatically set to after cache regeneration. dirty false : A function that, when returning , forces the object to have its own isolated cache, even if it is inside a group. By default, this function returns . needsItsOwnCache true false Please note that the specific properties mentioned in the article may vary depending on the Fabric.js version you are using. Use requestAnimationFrame To ensure smooth and efficient animation in Fabric.js, use the function to update the canvas. Syncing this function with the browser's rendering engine results in better performance and smoother animations. requestAnimationFrame Here's an example: function animate() {
  // Update canvas and objects here

  // Request the next animation frame
  fabric.util.requestAnimFrame(animate);
}

// Start the animation
animate(); By using , you optimize the animation performance in Fabric.js. requestAnimationFrame Minimize Redraws To avoid unnecessary redraws and improve performance, use the property to track changes and selectively render only the objects that need updating. It is especially useful when you have a large canvas with a lot of objects on it. dirty Here's an example: // Set an object as dirty to indicate changes
object.dirty = true;

// Render only dirty objects
canvas.renderAll();

// Reset dirty state after rendering
object.dirty = false; By minimizing redraws to only the necessary objects, you optimize performance in Fabric.js. Use object grouping When you have multiple objects that are frequently updated together or share common properties, consider grouping them using . Grouping objects reduces the number of individual objects that Fabric.js needs to render and update, improving performance. fabric.Group You can still interact with and manipulate the grouped objects as a single entity. Here's an example: // Create objects
var rect1 = new fabric.Rect({
    width: 50,
    height: 50,
    fill: 'red'
});
var rect2 = new fabric.Rect({
    width: 50,
    height: 50,
    fill: 'blue'
});

// Group objects
var group = new fabric.Group([rect1, rect2]);

// Add group to the canvas
canvas.add(group); Limit object complexity If you have complex objects with a large number of points, paths, or patterns, consider simplifying or optimizing them to improve performance. Simplifying the geometry or reducing the number of points in paths can significantly reduce the rendering and manipulation time for those objects. Additionally, avoid using overly large or high-resolution images as object fills or patterns, as they can slow down the rendering process. Use event delegation for interactivity With Fabric.js, you can respond to user interactions, such as clicks, mouse movements, and keyboard inputs. However, attaching event listeners to each individual object on the canvas can become inefficient, especially with a large number of objects. To optimize performance, you can utilize event delegation. Instead of attaching event listeners to each object, you attach a single event listener to the canvas itself and use event delegation to handle the events. of using event delegation for mouse clicks: Here's an example canvas.on('mouse:down', function(event) {
  var target = event.target;
  // Handle the click event on the target object
  if (target) {
    // Do something with the clicked object
  }
}); By using event delegation, you reduce the number of event listeners and improve performance, especially when dealing with a complex canvas with many interactive objects. Remember to adjust the event types and event handling based on your specific requirements, such as 'mouse:move', 'mouse:up', or other relevant events for the interactions you want to support in your application. Optimize rendering performance with fabric.util.requestRenderAll() Fabric.js provides a utility function called that can be used to optimize rendering performance, especially when you have multiple changes happening on the canvas simultaneously. fabric.util.requestRenderAll() Instead of calling multiple times after each change, you can use to batch the rendering calls and ensure efficient rendering. canvas.renderAll() fabric.util.requestRenderAll() Here's an example: fabric.util.requestRenderAll(); // Request rendering for all changes

// Make multiple changes to the canvas
object1.set({
    left: 100,
    top: 100
});
object2.set({
    fill: 'blue'
});
object3.remove();

// Call renderAll() once after making all the changes
canvas.renderAll(); By using , you optimize rendering performance by avoiding unnecessary intermediate rendering calls and ensuring that the final rendering is done efficiently. fabric.util.requestRenderAll() Use canvas.renderAll() or canvas.requestRenderAll() at the appropriate point in your code to trigger actual canvas rendering. Optimize image loading with lazy loading If your canvas contains a large number of images or complex image assets, loading all of them upfront can slow down the initial rendering process. To improve performance, consider implementing lazy loading techniques for image assets. Lazy loading involves loading images only when they are needed or when they come into the viewport. By deferring the loading of images that are initially out of view or not immediately required, you can reduce the initial load time and improve the overall performance of your Fabric.js canvas. of lazy loading images in Fabric.js Here's an example var imageElement = document.createElement('img');
imageElement.src = 'path/to/image.jpg';

// Add the image to the canvas when needed
imageElement.onload = function() {
    var fabricImage = new fabric.Image(imageElement);
    canvas.add(fabricImage);
}; By dynamically loading images when necessary, you can optimize the performance of your canvas and provide a smoother user experience, especially when dealing with large or numerous image assets. Remember to handle any error cases and implement appropriate fallback mechanisms to ensure that images are still loaded correctly even if lazy loading fails for any reason. Implementing lazy loading for images can be particularly beneficial when dealing with complex applications or scenarios where image assets are fetched dynamically based on user interactions or specific events. Dispose of unused objects and canvases When you no longer need certain objects or canvases in your Fabric.js application, it's important to dispose of them properly to free up memory and improve performance. Canvas objects that are no longer needed should be removed from the canvas by calling the method. canvas.remove(object) To properly dispose of canvas objects that are no longer in use, call . This will release any resources associated with the canvas and improve memory management. canvas.dispose() Here's an example: // Remove an object from the canvas
canvas.remove(object);

// Dispose of a canvas
canvas.dispose(); By disposing of unused objects and canvases, you prevent unnecessary memory usage and improve the overall performance of your Fabric.js application. It's important to regularly check your code for any objects or canvases that are no longer needed and properly dispose of them. This practice helps maintain a lean and efficient application, especially when dealing with large or complex scenarios. Conclusion In conclusion, Fabric.js is a powerful library for Canvas interactions and rendering. To optimize its performance, you can employ the following techniques: : Set the renderOnAddRemove property to false when initializing the canvas to prevent the entire canvas from being rerendered when objects are added or removed. Utilize renderOnAddRemove : Instead of using loadFromJSON, use enlivenObjects to manually add serialized JSON objects to the canvas, giving you more control over rendering and additional operations after loading. Use enlivenObjects instead of loadFromJSON : Convert non-interactive layers into image representations to reduce the workload on Fabric.js. Render those layers as images and overlay the canvas on top. Optimize by excluding non-interactive shapes : If interactivity is not needed, use fabric.StaticCanvas instead of fabric.Canvas to avoid rendering controls, borders, and corner detection. Utilize fabric.StaticCanvas : Adjust object properties like selection, controls, borders, rotating points, and canvas selection to optimize performance. Fine-tune object properties : Take advantage of automatic object caching in Fabric.js to improve performance for complex objects or large SVGs. Customize caching behavior using properties like , , , , and . Enable object caching objectCaching statefulCache noScaleCache dirty needsItsOwnCache : Use to update the canvas for smooth and efficient animation. Use requestAnimationFrame requestAnimationFrame : Use the property to track changes and selectively render only the objects that need updating. Minimize redraws dirty : Group objects together using fabric.Group to reduce the number of individual objects that need rendering and updating. Use object grouping : Simplify or optimize complex objects with a large number of points, paths, or patterns to improve performance. Limit object complexity : Attach a single event listener to the canvas and utilize event delegation to handle events for multiple objects efficiently. Use event delegation for interactivity : Use this utility function to batch rendering calls when making multiple changes to the canvas. Optimize rendering performance with fabric.util.requestRenderAll() : Implement lazy loading techniques to load images only when needed, reducing initial load time. Optimize image loading with lazy loading : Properly remove objects from the canvas and dispose of unused canvases to free up memory and improve performance. Dispose of unused objects and canvases You can optimize Fabric.js' performance and enhance your applications' user experience by applying these techniques.

Optimizing Performance in Fabric.js 5: 14 Best Practices and Tips

Using , you can create interactive and engaging graphical applications that work with canvas. One of the highly customizable aspects of Fabric.js is the ability to change the default rotate icon. Fabric.js HTML5 To customize the rotate icon in Fabric.js, follow this comprehensive step-by-step guide to add a unique touch to your canvas-based projects. Step 1: Preparing the Icon Prepare the custom icon you want to use for the new rotate icon first. Assume you have an SVG icon named "custom_rotate_icon.svg". To convert the icon file into a Base64 encoded string, you can use the in JavaScript. FileReader API Here's an example code snippet to accomplish this: // Read the SVG icon file
const iconFile = "custom_rotate_icon.svg";

// Convert the file to a Base64 encoded string
const reader = new FileReader();
reader.onload = function (e) {
  const base64Icon = btoa(e.target.result);
  // Use the base64Icon string as the custom rotate icon
  // Proceed to Step 2
};
reader.readAsBinaryString(iconFile); Step 2: Integrating the Custom Icon In your Fabric.js code, locate the section where the rotate icon is defined. Typically, you'll find a constant variable named . Replace the existing Base64 encoded string with the one representing your custom icon. ROTATE_ICON Here's an example code snippet illustrating this integration: // Replace the existing rotate icon with the custom icon
const ROTATE_ICON = base64Icon; Step 3: Rendering the Icon Next, we'll define a rendering function that will be responsible for drawing the custom rotate icon on the canvas. Within the provided code, you'll find a function named . As a programmer, you can modify this function to suit your specific positioning and styling preferences. renderIcon() , where we customize the position and size of the icon: Consider the following example code snippet function renderIcon(ctx, left, top, styleOverride, fabricObject) {
  const size = 16;
  ctx.save();
  ctx.translate(left, top);
  ctx.rotate(fabric.util.degreesToRadians(fabricObject.angle));
  ctx.drawImage(imgIcon, -size / 2, -size / 2, size, size);
  ctx.restore();
} Step 4: Configuring the Control Now, we'll create a new control object that represents the rotation control, incorporating our custom icon. Within the provided code, you'll notice the creation of a control object named using . This object allows us to define various properties such as the position offsets, action handler, cursor style handler, connection options, action name, and the render function that will be responsible for rendering the control icon. mtr new fabric.Control() demonstrating the configuration of the control: Here's an example code snippet // Create the custom control object
const mtr = new fabric.Control({
  x: -0.6,
  y: 0.6,
  actionHandler: controlsUtils.rotationWithSnapping,
  cursorStyleHandler: controlsUtils.rotationStyleHandler,
  withConnection: true,
  actionName: 'rotate',
  render: renderIcon,
}); Step 5: Assigning the Custom Control The final step is to assign the newly created control object ( ) to the property of both and . This ensures that the custom control is available for all fabric objects and textboxes created within your application. mtr mtr fabric.Object.prototype.controls fabric.Textbox.prototype.controls illustrating this assignment: Consider the following code snippet // Assign the custom control to fabric.Object.prototype.controls
fabric.Object.prototype.controls.mtr = mtr;

// Assign the custom control to fabric.Textbox.prototype.controls
fabric.Textbox.prototype.controls.mtr = mtr; Conclusion: By meticulously following these comprehensive steps and incorporating your own custom icon, you can easily customize the rotate icon in Fabric.js to seamlessly blend with your design requirements. Whether you intend to add a personal touch or align the icon with your project's branding, the ability to customize the rotate icon provides unparalleled flexibility and enhances the visual appeal of your canvas-based applications. Don't hesitate to explore other customization options offered by Fabric.js to further tailor the library to your specific needs. Unleash your creativity and embark on a journey of creating remarkable canvas-based applications with Fabric.js!

How to Customize Rotate Icons in Fabric.js: A Comprehensive Guide for Programmers

When we hear the word "group," we often think of various associations, from social circles to musical bands or even a gathering of animals. A Fabric.js group is a collection of objects that are clustered together. These groups serve multiple purposes, such as moving and modifying objects collectively or applying property changes uniformly across multiple objects. In this blog post, we will explore how to create object groups using Fabric.js, empowering you to streamline your object manipulation and modification tasks. Why Use Object Groups in Fabric.js: Object groups offer several advantages and functionalities, including: With object groups, you can conveniently move multiple objects as a single unit, simplifying the positioning and arrangement of complex scenes. Moving Multiple Objects Together: By grouping objects, you can apply modifications uniformly across the entire group, saving time and effort when making changes to related objects. Modifying Objects as a Group: Object groups enable simultaneous property changes, allowing you to apply transformations like skewing, scaling, fill color, stroke, and more to multiple objects at once. Applying Property Changes: Creating Object Groups in Fabric.js: To create an object group in Fabric.js, we utilize the fabric.Group constructor. Let's take a closer look at its syntax and usage: Syntax: new fabric.Group(objects: Object, 
                  options(optional): Object, 
                  isAlreadyGrouped(optional): Boolean); The parameter accepts an array of objects that we want to group together. objects Optional can be passed as an object, allowing customization of group properties like position and angle. options The parameter is used to indicate if the provided objects are already grouped. isAlreadyGrouped Creating a Basic Object Group: Follow these steps to create a basic object group: You can group shapes, images, or text elements by creating individual objects. Pass these objects as an array to the constructor. fabric.Group Example: var circle = new fabric.Circle({ radius: 30, fill: "#FF0000" });
var image = new fabric.Image(...);
var text = new fabric.Text("Hello", ...);

var group = new fabric.Group([circle, image, text]);
canvas.add(group); A circle, an image, and a text element are combined in the above example. The variable represents the newly created object group, which is then added to the canvas. group Customizing Object Groups: You can further customize object groups by providing optional properties to the object parameter. These properties allow you to define the group's position, rotation angle, and other visual attributes. options Example: var group = new fabric.Group([circle, image, text], {
  left: 70,
  top: 94,
  angle: -10,
}); In the above example, we set the and properties to position the group on the canvas. Additionally, we specify an to rotate the entire group. left top angle Creating a Group of Two Objects: Creating a group of two objects follows a similar approach. However, we need to ensure proper alignment within the group by setting the and properties to "center" for each object. originX originY Example: var rect = new fabric.Rect({
    width: 100,
    height: 85,
    fill: "#FFC0CB",
    originX: "center",
    originY: "center"
});
var text = new fabric.Text("Hello world@", {
    fontSize: 30,
    originX: "center",
    originY: "center"
});

var group = new fabric.Group([rect, text], {
    left: 150,
    top: 100,
    angle: -10
});
canvas.add(group); In the above example, we create a group of a rectangle and text element. By specifying the and properties as "center" for each object, we ensure they are properly centered within the group. originX originY Ungrouping Fabric.js Objects In addition to creating groups of objects in Fabric.js, you also have the ability to ungroup them when needed. Ungrouping objects allows you to restore their individual properties and manipulate them independently. Let's explore how to ungroup objects using Fabric.js with an example. Example of Ungrouping Objects: You want to ungroup a group of objects and treat them separately. Consider a group consisting of two rectangles and a text element. We will demonstrate how to ungroup them using Fabric.js. var canvas = new fabric.Canvas("canvas");

// Create the rectangles
var rect1 = new fabric.Rect({
  width: 100,
  height: 50,
  fill: "blue",
  left: 50,
  top: 50,
});

var rect2 = new fabric.Rect({
  width: 100,
  height: 50,
  fill: "red",
  left: 200,
  top: 50,
});

// Create the text element
var text = new fabric.Text("Hello", {
  fontSize: 20,
  fill: "white",
  left: 120,
  top: 60,
});

// Group the objects
var group = new fabric.Group([rect1, rect2, text], {
  left: 100,
  top: 100,
});

canvas.add(group);

// Ungroup the objects
var activeObj = canvas.getActiveObject();
var activegroup = activeObj.toGroup();
var objectsInGroup = activegroup.getObjects();

activegroup.clone(function(newgroup) {
    canvas.remove(activegroup);
    objectsInGroup.forEach(function(object) {
        canvas.remove(object);  
    });
    canvas.add(newgroup);
    canvas.setActiveObject(newgroup);
    canvas.requestRenderAll();
});

canvas.renderAll(); In the code above, we assume that canvas is the Fabric.js canvas object. First, we retrieve the active object from the canvas using . We then convert the active object into a group using the method, and store it in the activegroup variable. getActiveObject() toGroup() A list of objects within the group is obtained using the method and stored in the variable. getObjects() objectsInGroup A clone of the activegroup is then created using the clone() method. Inside the callback function of clone(), we remove the activegroup from the canvas using . remove(activegroup) We iterate over the objectsInGroup array and remove each individual object from the canvas using . remove(object) After removing the group and its objects, we add the cloned group back to the canvas using . add(newgroup) Finally, we set the newgroup as the active object on the canvas using , and request the canvas to render the changes using By executing this code, you will ungroup the objects and have them restored as separate entities on the canvas. setActiveObject(newgroup) requestRenderAll(). Conclusion Mastering object grouping in Fabric.js empowers you to simplify object manipulation and modification tasks. By creating object groups, you can move, modify, and apply property changes to multiple objects simultaneously, enhancing your productivity and efficiency. Whether you're working with complex scenes or need to apply uniform transformations, object groups in Fabric.js are a valuable tool in your development arsenal. Start leveraging the power of object grouping in Fabric.js and take your canvas-based applications to the next level.

Stories, News & Mentions about FABRICK

Fabrick’s Stories on HackerNoon

Fabrick's News & Mentions