Problem to login in Joomla administrator, seems not working.
configuration apache – mysql – PHP 7.4.23 – ispconfig
the problem was session.cookie_secure = 1 in the php.ini.
the correct value has to be session.cookie_secure = 0
I don't know what's the matter with people: they don't learn by understanding, they learn by some other way — by rote or something. Their knowledge is so fragile! (Feynman)
Problem to login in Joomla administrator, seems not working.
configuration apache – mysql – PHP 7.4.23 – ispconfig
the problem was session.cookie_secure = 1 in the php.ini.
the correct value has to be session.cookie_secure = 0
Nonostante le numerose differenze, tutte le Blockchain possiedono le seguenti caratteristiche:
L’obiettivo della classificazione che segue è identificare le differenze non solo ad alto livello ma anche a un livello di applicazione. Le distinzioni che si possono fare sono legate alle dimensioni di pubblicità della rete e della presenza o assenza di permessi di accesso ad essa. Senza addentrarci in questioni troppo tecniche, diciamo che le principali differenze fra Blockchain, quando si parla di queste due dimensioni, sono rilevabili a livello dei partecipanti. Chi è autorizzato a
Esistono principalmente tre tipologie di Blockchain: pubbliche, permissioned e private. Non si tratta di una classificazione rigida. Anzi, gli elementi caratterizzanti di queste declinazioni possono essere combinati in un’ampia varietà di modalità, per creare registri personalizzati per applicazioni specifiche.
Le Blockchain permissionless o pubbliche vengono definite così perché richiedono alcuna autorizzazione per poter accedere alla rete, eseguire delle transazioni o partecipare alla verifica e creazione di un nuovo blocco.
Le più famose sono sicuramente Bitcoin ed Ethereum, dove non vi sono restrizioni o condizioni di accesso. Chiunque può prenderne parte. Si tratta di una struttura completamente decentralizza, in quanto non esiste un ente centrale che gestisce le autorizzazioni di accesso. Queste sono condivise tra tutti i nodi allo stesso modo. Nessun utente della rete ha privilegi sugli altri, nessuno può controllare le informazioni che vengono memorizzate su di essa, modificarle o eliminarle, e nessuno può alterare il protocollo che determina il funzionamento di questa tecnologia.
I concetti di permissionless e publicness sono strettamente legati tra loro. Sarebbe un controsenso avere una Blockchain privata dove però non viene richiesta un’autorizzazione per accedere ai dati registrati; per questo motivo tutte quelle che non richiedono un’approvazione sono definite pubbliche. Nonostante i dati registrati su queste Blockchain siano pubblici, questi vengono crittografati per mantenere un sufficiente livello di privacy. Ad esempio tutti i nodi di Bitcoin conoscono gli indirizzi wallet degli altri utenti e le transazioni che sono avvenute tra di loro. In linea di principio questi indirizzi sono semplicemente pseudonimi e, a meno che non vengano ricondotti all’identità della persona del mondo reale che ne è il proprietario, viene garantito un livello di privacy sufficiente. Un metodo per proteggere ulteriormente la propria identità consiste nell’utilizzare più di un singolo indirizzo wallet.
La principale preoccupazione legata alle Blockchain pubbliche è il tema della scalabilità, ovvero la capacità di un sistema di migliorarsi all’aumentare del numero di partecipanti. Questo tipo di rete non è una tecnologia scalabile: al crescere della quantità di nodi, la velocità delle transazioni rimane invariata ma aumenta la stabilità del sistema che diventa così più sicuro.
Le Blockchain permissioned sono soggette ad un’autorità centrale che determina chi possa accedervi. Oltre a definire chi è autorizzato a far parte della rete, tale autorità definisce quali sono i ruoli che un utente può ricoprire all’interno della stessa, definendo anche regole sulla visibilità dei dati registrati. Le Blockchain permissioned introducono quindi il concetto di governance e centralizzazione in una rete che nasce come assolutamente decentralizzata e distribuita.
Chiamata comunemente Blockchain del Consorzio, invece di consentire a qualsiasi persona con una connessione Internet di partecipare alla verifica del processo di transazione, affida il compito ad alcuni nodi selezionati ritenuti degni di fiducia.
Un esempio esplicativo di questa tipologia di rete può essere costituito da un consorzio composto da 10 aziende, ognuna di esse collegata alla Blockchain grazie un computer. Se la società “7” ha rapporti lavorativi solo con “1”, “3” e “6” condividerà le fatture solo con queste tre senza che sia necessario autorizzare le altre società a leggere i dati tra loro condivisi.
Nelle reti pubbliche come Bitcoin, viene richiesto ai miner di dimostrare una proof-of-work, ovvero svolgere un task molto dispendioso in termini di tempo ed energia. Quindi più una transazione si trova in profondità nel registro maggiore è il lavoro che un nodo deve fare per poterla eliminare o modificare e ricostruire tutti i blocchi successivi ad essa, mentre la catena continua a crescere grazie al lavoro degli altri utenti. Il protocollo di Bitcoin rende quindi estremamente svantaggioso sul piano economico tentare di riscrivere la Blockchain, garantendone così l’immutabilità.
Le Blockchain autorizzate non garantiscono questa proprietà, poiché non sono in grado di assicurare l’immutabilità. Ogni volta che l’algoritmo che determina la modalità per la generazione di un nuovo blocco e del consenso non richiede ai nodi di spendere in modo irreversibile una qualche forma di energia e di tempo, in realtà ci stiamo affidando alla loro buona fede, piuttosto che su un algoritmo prevedibile.
È bene sottolineare che una Blockchain permissioned non è necessariamente anche privata. Esistono, infatti, diversi livelli di accesso che riguardano:
Mentre l’ultimo livello di accesso, quello relativo all’attività di mining, è concesso solo ad un insieme limitato di utenti in questo tipo di Blockchain, gli altri due non sono obbligatoriamente sottoposti ad un’autorizzazione. Al contrario le organizzazioni o le istituzioni finanziarie a capo di una Blockchain autorizzata potrebbero decidere di:
Le caratteristiche delle Blockchain permissioned le rendono più interessanti agli occhi delle grandi imprese e dalle istituzioni poiché vengono ritenute più sicure di quelle pubbliche e permettono di avere il livello di segretezza richiesto, controllando chi può accedervi e chi può visualizzare i dati registrati.
Le Blockchain autorizzate sono inoltre più performanti, veloci, scalabili e meno costose di quelle pubbliche, dato che hanno una dimensione e diffusione minore di esse e che le transazioni vengono verificate da un limitato numero di utenti.
Le Blockchain private condividono molte caratteristiche con quelle permissioned. Si tratta di reti private e non visibili, che sacrificano decentralizzazione, sicurezza e immutabilità in cambio di spazio di archiviazione, velocità di esecuzione e riduzione dei costi. Questo tipo di Blockchain viene controllato da un’organizzazione, ritenuta altamente attendibile dagli utenti, che determina chi possa accedere o meno alla rete e alla lettura dei dati in essa registrati.
L’organizzazione proprietaria della rete inoltre, ha il potere di modificare le regole di funzionamento della Blockchain stessa, rifiutando determinate transazioni in base alle regole e alle normative stabilite. Il fatto che sia necessario essere invitati ed autorizzati per poter accedervi garantisce un maggior livello di privacy agli utenti e determina la segretezza delle informazioni contenute.
Le Blockchain private possono essere considerate le più veloci e le più economiche, in quanto le transazioni sono verificate da un numero limitato di nodi riducendo così le tempistiche; pertanto le commissioni di transazione sono significativamente inferiori a quelle delle Blockchain pubbliche.
In questi ultimi anni le Blockchain private stanno riscuotendo maggior successo di quelle pubbliche tra le società private e le istituzioni finanziare grazie a cinque caratteristiche:
Queste tre tipologie di Blockchain possono venire assemblate in diversi modi, per rispondere al meglio alle necessità dell’utente. Di seguito vedremo le combinazioni più comuni:
very interesting video1 corse
very interesting video2 corse
very interesting video3 corse
very interesting video4 corse Use Ref
very interesting video5 cource useDispach
Flex container tutorial very fine
Create Project : npx create-react-app form
Install bootstrap : npm install react-bootstrap bootstrap
vs
Install martial-ui : npm install @material-ui/core @material-ui/icons
useful commands with Simple React Snippet installed in VCode
Comment Code Block Ctrl+K+C/Ctrl+K+U
Snippet | Renders |
---|---|
imr |
Import React |
imrc |
Import React / Component |
imrs |
Import React / useState |
imrse |
Import React / useState useEffect |
impt |
Import PropTypes |
impc |
Import React / PureComponent |
cc |
Class Component |
ccc |
Class Component With Constructor |
cpc |
Class Pure Component |
sfc |
Stateless Function Component |
cdm |
componentDidMount |
uef |
useEffect Hook |
cwm |
componentWillMount |
cwrp |
componentWillReceiveProps |
gds |
getDerivedStateFromProps |
scu |
shouldComponentUpdate |
cwu |
componentWillUpdate |
cdu |
componentDidUpdate |
cwu |
componentWillUpdate |
cdc |
componentDidCatch |
gsbu |
getSnapshotBeforeUpdate |
ss |
setState |
ssf |
Functional setState |
usf |
Declare a new state variable using State Hook |
ren |
render |
rprop |
Render Prop |
hoc |
Higher Order Component |
react native snippets install plugin in visual code
rfc
syntax example code :
tag : [‘tag1’, ‘tag2’, ‘tag3’]
{tags.map(tag => <li key={tag.id}>{tag}</li>)}
tags.map((item, index) => (
<FormControlLabel value={item.id} control={<Radio />} label={item.title}>
))
handleIncrement() {
if “this” is called in a part of a method of object : obj.method() this is the reference of the obj
if “this” is called in the function : function() return a reference to the window
object so can be undefined id the strict mode is enabled
}
contructor() {
super();// referring to the extend class ex Component
console.log(‘Contructor’, this);
this.handleIncrement = this.handleIncrement.bind(this);
}
OR
handleIncrement = () => {
console.log(‘Contructor’, this);
}
setState(prevState => {
return { …prevState, {count: prevState.count – 1} }
})
ADD a router
create-react-app material-ui-react-router
OR
install datepicker MUI npm i @material-ui/pickers npm i @date-io/date-fns@1.x date-fns
npm install @material-ui/lab
npm install axios
I can use the ThremeProvider in the index.js to import the default theme to customize
const [index, setIndex] = useState(0);
const [shiftArr, setShiftArr] = useState([]);
update react project :
sudo npm install -g npm-check-updates
In this article, we’ll show different ways to capture a heap dump in Java.
A heap dump is a snapshot of all the objects that are in memory in the JVM at a certain moment. They are very useful to troubleshoot memory-leak problems and optimize memory usage in Java applications.
Heap dumps are usually stored in binary format hprof files. We can open and analyze these files using tools like jhat or JVisualVM. Also, for Eclipse users it’s very common to use MAT.
In the next sections, we’ll go through multiple tools and approaches to generate a heap dump and we’ll show the main differences between them.
The JDK comes with several tools to capture heap dumps in different ways. All these tools are located under the bin folder inside the JDK home directory. Therefore, we can start them from the command line as long as this directory is included in the system path.
In the next sections, we’ll show how to use these tools in order to capture heap dumps.
jmap is a tool to print statistics about memory in a running JVM. We can use it for local or remote processes.
To capture a heap dump using jmap we need to use the dump option:
jmap -dump:[live],format=b,file=<file-path> <pid>
Along with that option, we should specify several parameters:
An example would be like this:
jmap -dump:live,format=b,file=/tmp/dump.hprof 12587
Remember that we can easily get the pid of a Java process by using the jps command.
Keep in mind that jmap was introduced in the JDK as an experimental tool and it’s unsupported. Therefore, in some cases, it may be preferable to use other tools instead.
jcmd is a very complete tool that works by sending command requests to the JVM. We have to use it in the same machine where the Java process is running.
One of its many commands is the GC.heap_dump. We can use it to get a heap dump just by specifying the pid of the process and the output file path:
jcmd <pid> GC.heap_dump <file-path>
We can execute it with the same parameters that we used before:
jcmd 12587 GC.heap_dump /tmp/dump.hprof
As with jmap, the dump generated is in binary format.
JVisualVM is a tool with a graphical user interface that lets us monitor, troubleshoot, and profile Java applications. The GUI is simple but very intuitive and easy to use.
One of its many options allows us to capture a heap dump. If we right-click on a Java process and select the “Heap Dump” option, the tool will create a heap dump and open it in a new tab:
Notice that we can find the path of the file created in the “Basic Info” section.
Starting from JDK 9, Visual VM is not included in the Oracle JDK and Open JDK distributions. Therefore, if we’re using Java 9 or newer versions, we can get the JVisualVM from the Visual VM open source project site.
All the tools that we’ve shown in the previous sections are intended to capture heap dumps manually at a specific time. In some cases, we want to get a heap dump when a java.lang.OutOfMemoryError occurs so it helps us investigate the error.
For these cases, Java provides the HeapDumpOnOutOfMemoryError command-line option that generates a heap dump when a java.lang.OutOfMemoryError is thrown:
java -XX:+HeapDumpOnOutOfMemoryError
By default, it stores the dump in a java_pid<pid>.hprof file in the directory where we’re running the application. If we want to specify another file or directory we can set it in the HeapDumpPath option:
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=<file-or-dir-path>
When our application runs out of memory using this option, we’ll be able to see in the logs the created file that contains the heap dump:
java.lang.OutOfMemoryError: Requested array size exceeds VM limit
Dumping heap to java_pid12587.hprof ...
Exception in thread "main" Heap dump file created [4744371 bytes in 0.029 secs]
java.lang.OutOfMemoryError: Requested array size exceeds VM limit
at com.baeldung.heapdump.App.main(App.java:7)
In the example above, it was written to the java_pid12587.hprof file.
As we can see, this option is very useful and there is no overhead when running an application with this option. Therefore, it’s highly recommended to use this option always, especially in production.
Finally, this option can also be specified at runtime by using the HotSpotDiagnostic MBean. To do so, we can use JConsole and set the HeapDumpOnOutOfMemoryError VM option to true:
We can find more information about MBeans and JMX in this article.
The last approach that we’ll cover in this article is using JMX. We’ll use the HotSpotDiagnostic MBean that we briefly introduced in the previous section. This MBean provides a dumpHeap method that accepts 2 parameters:
In the next sections, we’ll show 2 different ways to invoke this method in order to capture a heap dump.
The easiest way to use the HotSpotDiagnostic MBean is by using a JMX client such as JConsole.
If we open JConsole and connect to a running Java process, we can navigate to the MBeans tab and find the HotSpotDiagnostic under com.sun.management. In operations, we can find the dumpHeap method that we’ve described before:
As shown, we just need to introduce the parameters outputFile and live into the p0 and p1 text fields in order to perform the dumpHeap operation.
The other way to use the HotSpotDiagnostic MBean is by invoking it programmatically from Java code.
To do so, we first need to get an MBeanServer instance in order to get an MBean that is registered in the application. After that, we simply need to get an instance of a HotSpotDiagnosticMXBean and call its dumpHeap method.
Let’s see it in code:
public static void dumpHeap(String filePath, boolean live) throws IOException {
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
HotSpotDiagnosticMXBean mxBean = ManagementFactory.newPlatformMXBeanProxy(
server, "com.sun.management:type=HotSpotDiagnostic", HotSpotDiagnosticMXBean.class);
mxBean.dumpHeap(filePath, live);
}
Notice that an hprof file cannot be overwritten. Therefore, we should take this into account when creating an application that prints heap dumps. If we fail to do so we’ll get an exception:
Exception in thread "main" java.io.IOException: File exists
at sun.management.HotSpotDiagnostic.dumpHeap0(Native Method)
at sun.management.HotSpotDiagnostic.dumpHeap(HotSpotDiagnostic.java:60)
In this tutorial, we’ve shown multiple ways to capture a heap dump in Java.
As a rule of thumb, we should remember to use the HeapDumpOnOutOfMemoryError option always when running Java applications. For other purposes, any of the other tools can be perfectly used as long as we keep in mind the unsupported status of jmap.
As always, the full source code of the examples is available over on GitHub.
From here for Eclipse analyzer.
This article describes the usage of the Eclipse Memory Analyzer (MAT) to identify memory leaks.
The Eclipse Memory Analyser Tooling (MAT) is a set of plug-ins for the Eclipse IDE which provides tools to analyze heap dumps from Java application and to identify memory problems in the application. This helps the developer to find memory leaks and high memory consumption issues.
It visualizes the references to objects based on Java heap dumps and provides tools to identify potential memory leaks.
A heap dump is a snapshot of the complete Java object graph on a Java application at a certain point in time. It is stored in a binary format called HPROF.
It includes all objects, fields, primitive types and object references.
Install Eclipse MAT via the
menu entry. Select the update site of your release from the drop-down box and once its content is downloaded, select General Purpose Tools and its sub-entries Memory Analyzer and Memory Analyzer(Charts).It is possible to instruct the JVM to create automatically a heap dump in case that it runs out of memory, i.e. in case of a OutOfMemoryError
error. To instruct the JVM to create a heap dump in such a situation, start your Java application with the -XX:+HeapDumpOnOutOfMemoryError option.
Use the
menu entry to open a dialog to select for which process you want to acquire a memory dump.Select the process for a heap dump in the following dialog and press the Finish button.
Alternatively you can also interactively create a heap dump via Eclipse. For this, open the Memory Analysis perspective via
.If you trigger the creation of the heap manually the JVM performs sa garbage collector run before it writes the heap dump.
After a new heap dump with the .hprof ending has been created, you can open it via a double-click in Eclipse. If you used MAT to create the heap dump, it should be opened automatically.
You may need to refresh your project (F5 on the project). Double-click the file and select the Leak Suspects Report.
The overview page allows you to start the analysis of the heap dump. The dominator tree gives quickly an overview of the used objects.
In the dominator tree you see the references which are hold.
To find which element is holding the reference to this object, select the entry and select Find shortest path to GC root from the context menu.
Android allows to create heap dumps of an application’s heap. This heap dump is stored in a binary format called HPROF. To create a heap dump use the Dump HPROF file button in the DDMS Perspective.
The Android heap dump format is similar to the Java heap dump format but not exactly the same. Eclipse MAT can work directly with the Android heap dump format.
Create the Java project called com.vogella.mat.first and the com.vogella.mat.first
package. Create the following class.
package com.vogella.mat.first;
import java.util.ArrayList;
import java.util.List;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
while (1<2){
list.add("OutOfMemoryError soon");
}
}
}
In Eclipse add the -XX:+HeapDumpOnOutOfMemoryError to the runtime configuration.
Run the project. It crashes and writes an heap dump.
Open the heap dump in MAT and get familiar with using the MAT tooling.
You can also interactively create a heap dumps via the jconsole, a tool which is included in the JDK. Type jconsole in the command line to start it.
To allow a Java program the access of jconsole use the -Dcom.sun.management.jmxremote start option.
Use them MBeans | com.sun.management | HotSpotDiagnostics | Operations |DumpHeap .
More info can be found in JConsole and JConsole Tutorial.
The stack is a part of memory that contains information about nested method calls down to the current position in the program. It also contains all local variables and references to objects on the heap defined in currently executing methods.
This structure allows the runtime to return from the method knowing the address whence it was called, and also clear all local variables after exiting the method. Every thread has its own stack.
The heap is a large bulk of memory intended for allocation of objects. When you create an object with the new keyword, it gets allocated on the heap. However, the reference to this object lives on the stack.
Let’s quickly summarize the differences between the Stack Memory and the Heap Space:
Parameter | Stack Memory | Heap Space |
---|---|---|
Application | Stack is used in parts, one at a time during execution of a thread | The entire application uses Heap space during runtime |
Size | Stack has size limits depending upon OS and is usually smaller then Heap | There is no size limit on Heap |
Storage | Stores only primitive variables and references to objects that are created in Heap Space | All the newly created objects are stored here |
Order | It is accessed using Last-in First-out (LIFO) memory allocation system | This memory is accessed via complex memory management techniques that include Young Generation, Old or Tenured Generation, and Permanent Generation. |
Life | Stack memory only exists as long as the current method is running | Heap space exists as long as the application runs |
Efficiency | Comparatively much faster to allocate when compared to heap | Slower to allocate when compared to stack |
Allocation/Deallocation | This Memory is automatically allocated and deallocated when a method is called and returned respectively | Heap space is allocated when new objects are created and deallocated by Gargabe Collector when they are no longer referenced |
La ragazza Danese (9)
Un ottima annata (6.5)
Martin Eden (8)
Opera senza autore (7)
Maurice (7)
Disobbedience (7)
Ammonite (7)
Il meglio deve ancora venire (7)
cosa mi lasci di te (7)
radioactive (6.9)
judy (6.9)
Le cose che non ti ho detto (7.5)
frantz (7.5)
Elisa e Marcela (7)
Dunkirk(7)
Le Pagine della nostra vita (7.5)
Lars e la ragazza tutta sua (7)
dalle 5 alle 7 : due ore d’amore (7.3)
La persona peggiore del mondo (7.1)
Blue Valentine (6.5)
Sulle Ali dell’avventura (6.5)
IL CLUB DEL LIBRO E DELLA TORTA DI BUCCE DI PATATA DI GUERNSEY(6/7)
Slipt (6.1)
Possession – Una storia romantica (7.5) sperando che un giorno le mie figlie siano innamorate cosi
La memoria del cuore , The vow(6.5)
Playing it cool (7.5)
Geisha (7.5)
Mery queen of Scots (7.6)